diff options
| author | Diego Novillo <dnovillo@google.com> | 2013-03-26 10:33:36 +0000 |
|---|---|---|
| committer | Diego Novillo <dnovillo@google.com> | 2013-03-26 10:33:36 +0000 |
| commit | 2a98a4059372b93af919c05fd68f3364e56c7008 (patch) | |
| tree | 61b7552b10852929b89f1cb93878fadffc1885c2 | |
| parent | f13a2ceb6b815892f592d14cf87edf1c17383457 (diff) | |
| parent | df552eec2bd8a867e1ce28b33d62a1aac099c4d1 (diff) | |
Merged revisions 196607-196608,196611-196614,196625,196629-196634,196636,196639,196645-196647,196649-196650,196654-196659,196666,196669,196671-196675,196682-196683,196694-196695,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-196807,196810-196814,196821,196823-196825,196828-196829,196831-196832,196834,196841-196842,196847-196853,196855-196856,196858,196860-196861,196864-196866,196868,196870-196872,196874,196876,196878-196879,196882,196884-196890,196896-196897,196899-196902,196954,196956-196961,196964-196965,196970,196977-196978,196981-196983,196989,197002-197005,197007,197011-197012,197016-197019,197021,197023-197025,197029-197034,197036-197042 via svnmerge from cxx-conversion
svn+ssh://gcc.gnu.org/svn/gcc/trunk
git-svn-id: https://gcc.gnu.org/svn/gcc/branches/cxx-conversion@197098 138bc75d-0d04-0410-961f-82ee72b054a4
455 files changed, 15794 insertions, 8156 deletions
diff --git a/ChangeLog b/ChangeLog index 6ef875812c6..e7f9cc0740a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +2013-02-24 Tilo Schwarz <tilo@tilo-schwarz.de> + + * MAINTAINERS (Write After Approval): Add myself. + 2013-02-20 Andrew Sutton <andrew.n.sutton@gmail.com> * MAINTAINERS (Write After Approval): Add myself. diff --git a/MAINTAINERS b/MAINTAINERS index 9affec84353..8fd35c46484 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -505,6 +505,7 @@ Hariharan Sandanagobalane hariharan.gcc@gmail.com Iain Sandoe iain@codesourcery.com Duncan Sands baldrick@gcc.gnu.org William Schmidt wschmidt@linux.vnet.ibm.com +Tilo Schwarz tilo@tilo-schwarz.de Dodji Seketeli dodji@gcc.gnu.org Svein Seldal svein@dev.seldal.com Thiemo Seufer ths@networkno.de diff --git a/contrib/ChangeLog b/contrib/ChangeLog index 4339d3c2ddd..c97ae95c3a8 100644 --- a/contrib/ChangeLog +++ b/contrib/ChangeLog @@ -1,3 +1,7 @@ +2013-03-22 Jakub Jelinek <jakub@redhat.com> + + * gennews (files): Add files for GCC 4.8. + 2013-03-06 Tobias Burnus <burnus@net-b.de> * make-obstacks-texi.pl: New. @@ -33,7 +37,7 @@ * update-copyright.py: New file. -2013-01-15 David Blaikie <dblaikie@gmail.com> +2013-01-15 David Blaikie <dblaikie@gmail.com> * dg-extract-results.sh: Handle KPASSes. @@ -289,8 +293,8 @@ * repro_fail: Add --debug and --debug-tui flags. -2012-02-02 Sumanth G <sumanth.gundapaneni@kpitcummins.com> - Jayant R Sonar <jayant.sonar@kpitcummins.com> +2012-02-02 Sumanth G <sumanth.gundapaneni@kpitcummins.com> + Jayant R Sonar <jayant.sonar@kpitcummins.com> * config-list.mk (LIST): Add cr16-elf. @@ -708,7 +712,7 @@ * compare-debug: New. 2007-08-16 H.J. Lu <hongjiu.lu@intel.com> - Andreas Schwab <schwab@suse.de> + Andreas Schwab <schwab@suse.de> * gcc_update: Use "svn info" for revision number. Create gcc/REVISION with branch name and revision number. @@ -849,7 +853,7 @@ * gcc_build: Remove -d from the call to gcc_update. 2005-10-28 Daniel Berlin <dberlin@dberlin.org> - Ben Elliston <bje@au1.ibm.com> + Ben Elliston <bje@au1.ibm.com> * gcc_update: Update for svn. * newcvsroot: Ditto. @@ -951,7 +955,7 @@ * gcc_update: libjava/configure.in -> configure.ac. -2004-08-03 Richard Earnshaw <rearnsha@arm.com> +2004-08-03 Richard Earnshaw <rearnsha@arm.com> * gcc_update: gcc/config/arm/arm-tune.md -> arm-cores.def gentune.sh. @@ -1118,7 +1122,7 @@ gcc/testsuite/gcc.dg/cpp/_Pragma3.c depends on gcc/testsuite/gcc.dg/cpp/mi1c.h. -2003-05-23 Nathanael Nerode <neroden@gcc.gnu.org> +2003-05-23 Nathanael Nerode <neroden@gcc.gnu.org> * paranoia.cc: Fix spelling error. @@ -1133,7 +1137,7 @@ * test_summary: Add -h, print existing comments as help. -2003-03-03 H.J. Lu <hjl@gnu.org> +2003-03-03 H.J. Lu <hjl@gnu.org> * gcc_build: Use $GCC_CVS/$CVS instead of cvs. * gcc_update: Likewise. @@ -1216,7 +1220,7 @@ * enquire.c: Move from gcc. -2002-07-16 H.J. Lu <hjl@gnu.org> +2002-07-16 H.J. Lu <hjl@gnu.org> * gcc_update (touch_files): Pass -s to ${MAKE}. @@ -1289,7 +1293,7 @@ and @center. Allow [a-z] after @enumerate. Handle 0 and numbers greater than 9 in enumerations. -2001-11-07 Laurent Guerby <guerby@acm.org> +2001-11-07 Laurent Guerby <guerby@acm.org> * gcc_update (files_and_dependencies): Add Ada dependencies. @@ -1304,7 +1308,7 @@ gcc/java/parse-scan.c and gcc/java/keyword.h to list of files to touch. -2001-09-04 David.Billinghurst <David.Billinghurst@riotinto.com> +2001-09-04 David.Billinghurst <David.Billinghurst@riotinto.com> * gcc_update: (files_and_dependencies) Add gcc/java/parse.c gcc/java/parse-scan.c and gcc/java/keyword.h to list of files to @@ -1331,7 +1335,7 @@ Fri Jul 27 18:01:21 CEST 2001 Jan Hubicka <jh@suse.cz> * gcc_update: Dump timestamp in LAST_UPDATED. 2001-07-26 Andreas Jaeger <aj@suse.de>, - Hans-Peter Nilsson <hp@bitrange.com> + Hans-Peter Nilsson <hp@bitrange.com> * analyze_brprob: Fix documentation. @@ -1355,7 +1359,7 @@ Mon Jul 23 15:47:19 CEST 2001 Jan Hubicka <jh@suse.cz> * gcc_update: Remove entries for gcc.1, cpp.1, gcov.1. -2001-07-01 Zoltan Felleg <zfelleg@telnet.hu> +2001-07-01 Zoltan Felleg <zfelleg@telnet.hu> * warn_summary: Fix typo in a comment. @@ -1630,7 +1634,7 @@ Sun Jul 16 12:04:33 2000 Mark P Mitchell <mark@codesourcery.com> * index-prop: Use a single pattern. Also support *** cdiffs. -2000-04-28 Pavel Roskin <pavel_roskin@geocities.com> +2000-04-28 Pavel Roskin <pavel_roskin@geocities.com> * index-prop: Don't change /dev/null. @@ -1656,7 +1660,7 @@ Sun Nov 28 00:41:44 1999 William Bader (william@nscs.fast.net) * gcc_update: Allow patches compressed by bzip2. -1999-10-11 Martin v. Löwis <loewis@informatik.hu-berlin.de> +1999-10-11 Martin v. Löwis <loewis@informatik.hu-berlin.de> * newcvsroot: New file. @@ -1693,7 +1697,7 @@ Sun Nov 28 00:41:44 1999 William Bader (william@nscs.fast.net) * test_summary: Replace egcs with gcc. Update e-mail address. 1999-07-05 Gerald Pfeifer <pfeifer@dbai.tuwien.ac.at> - Jerry Quinn <jquinn@nortelnetworks.com> + Jerry Quinn <jquinn@nortelnetworks.com> * egcs_update (touch_files, apply_patch): New functions. Use them. New command-line option --patch. Split test of local @@ -1789,7 +1793,7 @@ Fri Oct 30 00:39:27 1998 Jeffrey A Law (law@cygnus.com) * egcs_update: Do touch java/parse.c and java/parse-scan.c. They're in the repo again. -Fri Oct 16 07:35:00 1998 Bruce Korb <korb@datadesign.com> +Fri Oct 16 07:35:00 1998 Bruce Korb <korb@datadesign.com> * egcs_update: Added gcc/fixinc/* generated files to touch list. @@ -1812,7 +1816,7 @@ Mon Oct 5 14:19:48 1998 Kaveh R. Ghazi <ghazi@caip.rutgers.edu> keywords that are preserved in the "warning type" summary and tighten up the "arg ???" regexp. -Tue Sep 22 07:30 Bruce Korb <korb@datadesign.com> +Tue Sep 22 07:30 Bruce Korb <korb@datadesign.com> * fixinc/inclhack.def: Not all C++ comments in C headers were treated alike. They are now. Also fixed syntax @@ -1826,7 +1830,7 @@ Wed Sep 16 16:06:51 1998 Kaveh R. Ghazi <ghazi@caip.rutgers.edu> * egcs_update: Additionally touch gcc/java/parse.[ch]. -Thu Sep 9 16:48 Bruce Korb <korb@datadesign.com> +Thu Sep 9 16:48 Bruce Korb <korb@datadesign.com> * fixinc/inclhack.def: Added two files required by SCO's Open Server 5's avoid_bool fix. @@ -1857,7 +1861,7 @@ Tue Aug 11 17:33:19 1998 Gerald Pfeifer <pfeifer@dbai.tuwien.ac.at> * egcs_update: New script. -1998-08-05 Bruce Korb <korbb@datadesign.com> +1998-08-05 Bruce Korb <korbb@datadesign.com> * fixinc/Makefile Added define for target machine so machine-specific tests @@ -1890,7 +1894,7 @@ Mon Jul 27 20:33:02 1998 Gerald Pfeifer <pfeifer@dbai.tuwien.ac.at> * test_summary: Corrected script name in comments providing documentation. Added linebreaks for lines with > 80 characters. -Fri Jun 19 02:36:59 1998 Alexandre Oliva <oliva@dcc.unicamp.br> +Fri Jun 19 02:36:59 1998 Alexandre Oliva <oliva@dcc.unicamp.br> * test_summary: New switch, -i, and environment variable, append_logs, for including files in the report. @@ -1900,7 +1904,7 @@ Fri Jun 19 02:36:59 1998 Alexandre Oliva <oliva@dcc.unicamp.br> * warn_summary: Update to Kaveh's latest version allowing to specify the last stage built. -1998-05-29 Bruce Korb <korbb@datadesign.com> +1998-05-29 Bruce Korb <korbb@datadesign.com> * fixinc/mkfixinc.sh Changes to make it easier to invoke on platforms that @@ -1910,7 +1914,7 @@ Fri Jun 19 02:36:59 1998 Alexandre Oliva <oliva@dcc.unicamp.br> Applied fixes from egcs/gcc/fixincludes from the past several months. -1998-05-28 Bruce Korb <korbb@datadesign.com> +1998-05-28 Bruce Korb <korbb@datadesign.com> * fixinc/*: Updated most everything for a first real try at getting "fast_fixincludes" working. diff --git a/contrib/gennews b/contrib/gennews index 524415a6869..962bef2f362 100755 --- a/contrib/gennews +++ b/contrib/gennews @@ -24,6 +24,7 @@ website=http://gcc.gnu.org/ files=" + gcc-4.8/index.html gcc-4.8/changes.html gcc-4.7/index.html gcc-4.7/changes.html gcc-4.6/index.html gcc-4.6/changes.html gcc-4.5/index.html gcc-4.5/changes.html diff --git a/gcc/BASE-VER b/gcc/BASE-VER index 88f181192c4..6ed7776bf32 100644 --- a/gcc/BASE-VER +++ b/gcc/BASE-VER @@ -1 +1 @@ -4.8.0 +4.9.0 diff --git a/gcc/ChangeLog b/gcc/ChangeLog index a31a28e92cc..c211bea081e 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,9 +1,1335 @@ +2013-03-25 Catherine Moore <clm@codesourcery.com> + + * config/mips/constraints.md (u, Udb7 Uead, Uean, Uesp, Uib3, + Uuw6, Usb4, ZS, ZT, ZU, ZV, ZW): New constraints. + * config/mip/predicates.md (lwsp_swsp_operand, + lw16_sw16_operand, lhu16_sh16_operand, lbu16_operand, + sb16_operand, db4_operand, db7_operand, ib3_operand, + sb4_operand, ub4_operand, uh4_operand, uw4_operand, + uw5_operand, uw6_operand, addiur2_operand, addiusp_operand, + andi16_operand): New predicates. + * config/mips/mips.md (compression): New attribute. + (enabled): New attribute. + (length): Consider compression in computing length. + (shift_compression): New code attribute. + (*add<mode>3): New operands. Record compression. + (sub<mode>3): Likewise. + (one_cmpl<mode>2): Likewise. + (*and<mode>3): Likewise. + (*ior<mode>3): Likewise. + (unnamed pattern for xor): Likewise. + (*zero_extend<SHORT:mode><GPR:mode>2): Likewise. + (*<optab><mode>3): Likewise. + (*mov<mode>_internal: Likewise. + * config/mips/mips-protos.h (mips_signed_immediate_p): New. + (mips_unsigned_immediate_p): New. + (umips_lwsp_swsp_address_p): New. + (m16_based_address_p): New. + * config/mips/mips-protos.h (mips_signed_immediate_p): New prototype. + (mips_unsigned_immediate_p): New prototype. + (lwsp_swsp_address_p): New prototype. + (m16_based_address_p): New prototype. + * config/mips/mips.c (mips_unsigned_immediate_p): New function. + (mips_signed_immediate_p): New function. + (m16_based_address_p): New function. + (lwsp_swsp_address_p): New function. + (mips_print_operand_punctuation): Recognize short delay slot insns + for microMIPS.add<mode>3" + +2013-03-25 Kyrylo Tkachov <kyrylo.tkachov@arm.com> + PR target/56720 + * config/arm/iterators.md (v_cmp_result): New mode attribute. + * config/arm/neon.md (vcond<mode><mode>): Handle unordered cases. + +2013-03-25 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56689 + * tree-vrp.c (execute_vrp): Mark loops for fixup if we removed + any edge. + +2013-03-25 Richard Biener <rguenther@suse.de> + + * tree-ssa-loop-im.c (struct mem_ref): Use bitmap_head instead + of bitmap. + (memory_references): Likewise. + (outermost_indep_loop, mem_ref_alloc, mark_ref_stored, + gather_mem_refs_stmt, record_dep_loop, ref_indep_loop_p_1, + ref_indep_loop_p_2, find_refs_for_sm): Adjust. + (gather_mem_refs_in_loops): Fold into ... + (analyze_memory_references): ... this. Move initialization + to tree_ssa_lim_initialize. + (fill_always_executed_in): Rename to ... + (fill_always_executed_in_1): ... this. + (fill_always_executed_in): Move contains_call computation to + this new function from ... + (tree_ssa_lim_initialize): ... here. + (tree_ssa_lim): Call fill_always_executed_in. + +2013-03-25 Eric Botcazou <ebotcazou@adacore.com> + + * postreload.c (reload_combine): Fix code detecting returns. + +2013-03-25 Eric Botcazou <ebotcazou@adacore.com> + + * function.c (emit_use_return_register_into_block): On cc0 targets, + do not emit the sequence between cc0 setter and user. + +2013-03-25 Kai Tietz <ktietz@redhat.com> + + * config/i386/predicates.md (local_symbolic_operand): Interpret + dll-imported symbols as none-local. + +2013-03-25 Richard Biener <rguenther@suse.de> + + * tree-ssa-loop-im.c (struct depend): Remove. + (struct lim_aux_data): Make depends a vec of gimples. + (free_lim_aux_data): Adjust. + (add_dependency): Likewise. + (set_level): Likewise. + +2013-03-25 Richard Biener <rguenther@suse.de> + + PR middle-end/56434 + * calls.c (expand_call): Use MALLOC_ABI_ALIGNMENT to annotate + the pointer returned by calls with ECF_MALLOC set. + +2013-03-24 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/mmx.md (mov<mode>): Add ?!Ym,r and r,?!Ym alternatives. + +2013-03-24 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/mmx.md (mov<mode>): Merge with movv2sf expander + using MMXMODE mode iterator. + (*move<mode>_internal): Merge with *movv2sf_internal and + *movv2sf_internal_rex64 using MMXMODE mode iterator. + +2013-03-23 Steven Bosscher <steven@gcc.gnu.org> + + * gcse.c (oprs_unchanged_p): Respect flag_gcse_lm. + (record_last_mem_set_info): Likewise. + + * df-core.c (rest_of_handle_df_initialize): Use XCNEWVEC instead + of XNEWVEC followed by memset. + (df_worklist_dataflow): Use XNEWVEC instead of xmalloc with a cast. + +2013-03-23 Steven Bosscher <steven@gcc.gnu.org> + + * config/avr/avr.c, config/bfin/bfin.c, config/c6x/c6x.c, + config/epiphany/epiphany.c, config/frv/frv.c, config/ia64/ia64.c, + config/iq2000/iq2000.c, config/mcore/mcore.c, config/mep/mep.c, + config/mmix/mmix.c, config/pa/pa.c, config/rs6000/rs6000.c, + config/s390/s390.c, config/sparc/sparc.c, config/spu/spu.c, + config/stormy16/stormy16.c, config/v850/v850.c, config/xtensa/xtensa.c, + dwarf2out.c, hw-doloop.c, resource.c, rtl.h : Where applicable, use + the predicates NOTE_P, NONJUMP_INSN_P, JUMP_P, CALL_P, LABEL_P, and + BARRIER_P instead of GET_CODE. + +2013-03-23 Eric Botcazou <ebotcazou@adacore.com> + + * config/sparc/sparc.c (sparc_emit_probe_stack_range): Fix small + inaccuracy in the probing code. + + * config/sparc/sparc.md (ctrapsi4): Add predicate for operand #3. + (ctrapdi4): Likewise. + +2013-03-23 Eric Botcazou <ebotcazou@adacore.com> + + * calls.c (expand_call): Add missing guard to code handling return + of non-BLKmode structures in MSB. + * function.c (expand_function_end): Likewise. + +2013-03-23 Eric Botcazou <ebotcazou@adacore.com> + + * combine.c (try_combine): Adjust comment. Do not add the set of + insn #0 if the destination indirectly is set or dies in insn #2. + Tidy up code to distribute a new note. + +2013-03-22 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/i386.md (*movdi_internal): Set prefix_rex attribute + also for alternatives 16 and 17. + +2013-03-22 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/sse.md (*mov<mode>_internal): Merge with + *mov<mode>_internal_rex64. Use x64 and nox64 isa attributes. + Emit insn template depending on type attribute. Use + HAVE_AS_IX86_INTERUNIT_MOVQ to handle broken assemblers that require + movd instead of movq mnemonic for interunit moves. Rewrite mode + attribute calculation. Remove unit attribute calculation. + Set prefix attribute to maybe_vex for sselog1 and ssemov types. + Set prefix_data16 attribute for DImode ssemov types. + Use Ym instead of y for SSE-MMX conversion alternatives. + Reorder operand constraints. + +2013-03-22 Steven Bosscher <steven@gcc.gnu.org> + + * df.h (df_insn_delete): Adjust prototype. + * emit-rtl.c (remove_insn): Pass a basic block to df_insn_delete + and let it decide whether mark the basic block dirty. + (set_insn_deleted): Only pass INSN_P insns to df_insn_delete. + * df-scan.c (df_insn_info_delete): New helper function, split + off from df_insn_delete. + (df_scan_free_bb_info): Use it. + (df_insn_rescan, df_insn_rescan_all, df_process_deferred_rescans): + Likewise. + (df_insn_delete): Likewise. Take insn rtx as argument. Verify + that the insn is actually an insn and it has a non-NULL basic block. + Do not mark basic block dirty if only deleting a DEBUG_INSN. + +2013-03-22 Richard Biener <rguenther@suse.de> + + * tree-ssa-loop-im.c (struct mem_ref): Remove indep_ref and + dep_ref members. + (mem_ref_alloc): Do not allocate them. + (refs_independent_p): Do not query or maintain a cache. + +2013-03-22 Richard Biener <rguenther@suse.de> + + * tree-ssa-loop-im.c (memory_references): Drop all_refs_in_loop. + (gather_mem_refs_in_loops): Do not compute it. + (analyze_memory_references): Do not allocate it. + (tree_ssa_lim_finalize): Do not free it. + (for_all_locs_in_loop): Do not query all_refs_in_loop. + +2013-03-22 Richard Biener <rguenther@suse.de> + + * is-a.h (as_a): Use gcc_checking_assert. + +2013-03-22 Ian Bolton <ian.bolton@arm.com> + + * config/aarch64/aarch64.c (aarch64_print_operand): New + format specifier for printing a constant in hex. + * config/aarch64/aarch64.md (insv_imm<mode>): Use the X + format specifier for printing second operand. + +2013-03-22 Richard Biener <rguenther@suse.de> + + * tree-ssa-loop-im.c (memory_references): Add refs_stored_in_loop + bitmaps. + (gather_mem_refs_in_loops): Perform store accumulation here. + (create_vop_ref_mapping_loop): Remove. + (create_vop_ref_mapping): Likewise. + (analyze_memory_references): Initialize refs_stored_in_loop. + (LOOP_DEP_BIT): New define to map to bits in (in)dep_loop bitmaps. + (record_indep_loop): Remove. + (record_dep_loop): New function. + (ref_indep_loop_p_1): Adjust to only walk over references + in the loop, not its subloops. + (ref_indep_loop_p): Rename to ... + (ref_indep_loop_p_2): ... this and recurse over the loop tree, + maintaining a more fine-grained cache. + (ref_indep_loop_p): Wrap ref_indep_loop_p_2. + (tree_ssa_lim_finalize): Free refs_stored_in_loop. + +2013-03-22 Richard Biener <rguenther@suse.de> + + * tree-ssa-loop-im.c (struct mem_ref_locs): Remove. + (struct mem_ref): Make accesses_in_loop a vec of a vec of + aggregate mem_ref_loc. + (free_mem_ref_locs): Inline into ... + (memref_free): ... this and adjust. + (mem_ref_alloc): Adjust. + (mem_ref_locs_alloc): Remove. + (record_mem_ref_loc): Adjust. + (get_all_locs_in_loop): Rewrite into ... + (for_all_locs_in_loop): ... this iterator. + (rewrite_mem_ref_loc): New functor. + (rewrite_mem_refs): Use for_all_locs_in_loop. + (sm_set_flag_if_changed): New functor. + (execute_sm_if_changed_flag_set): Use for_all_locs_in_loop. + (ref_always_accessed): New functor. + (ref_always_accessed_p): Use for_all_locs_in_loop. + +2013-03-21 Marc Glisse <marc.glisse@inria.fr> + + * tree-pass.h (PROP_gimple_lvec): New. + * passes.c (dump_properties): Handle PROP_gimple_lvec. + (init_optimization_passes): Move pass_lower_vector. + * tree-vect-generic.c (gate_expand_vector_operations_ssa): Test + PROP_gimple_lvec. + (pass_lower_vector): Provide PROP_gimple_lvec. + (pass_lower_vector_ssa): Likewise. + * cfgexpand.c (pass_expand): Require PROP_gimple_lvec. + +2013-03-21 Mark Wielaard <mjw@redhat.com> + + * dwarf2out.c (size_of_aranges): Skip DECL_IGNORED_P functions. + +2013-03-21 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/i386.md (*movdi_internal): Disparage slightly + all MMX moves to/from memory. Use Yi instead of x for SSE-MMX + conversion alternatives. + +2013-03-21 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/48087 + * diagnostic.def (DK_WERROR): New kind. + * diagnostic.h (werrorcount): Define. + * diagnostic.c (diagnostic_report_diagnostic): For DK_WARNING + promoted to DK_ERROR, increment DK_WERROR counter instead of + DK_ERROR counter. + * toplev.c (toplev_main): Call print_ignored_options even if + just werrorcount is non-zero. Exit with FATAL_EXIT_CODE + even if just werrorcount is non-zero. + + PR debug/55608 + * dwarf2out.c (tree_add_const_value_attribute): Call ggc_free (array) + on failure. + (resolve_one_addr): Fail if referenced STRING_CST hasn't been written. + (string_cst_pool_decl): New function. + (optimize_one_addr_into_implicit_ptr): New function. + (resolve_addr_in_expr): Optimize DWARF location expression + DW_OP_addr DW_OP_stack_value where DW_OP_addr refers to some variable + which doesn't live in memory, but has DW_AT_location or + DW_AT_const_value, or refers to a string literal, into + DW_OP_GNU_implicit_pointer. + (optimize_location_into_implicit_ptr): New function. + (resolve_addr): If removing DW_AT_location of a variable because + it was DW_OP_addr of address of the variable, but the variable doesn't + live in memory, try to emit const value attribute for the initializer. + +2013-03-21 Marc Glisse <marc.glisse@inria.fr> + + * tree.h (VECTOR_TYPE_P): New macro. + (VECTOR_INTEGER_TYPE_P, VECTOR_FLOAT_TYPE_P, FLOAT_TYPE_P, + TYPE_MODE): Use it. + * fold-const.c (fold_cond_expr_with_comparison): Use build_zero_cst. + VEC_COND_EXPR cannot be lvalues. + (fold_ternary_loc) <VEC_COND_EXPR>: Merge with the COND_EXPR case. + +2013-03-21 Marc Glisse <marc.glisse@inria.fr> + + * simplify-rtx.c (simplify_binary_operation_1) <VEC_CONCAT>: + Restrict the transformation to equal modes. + +2013-03-21 Richard Biener <rguenther@suse.de> + + PR tree-optimization/39326 + * tree-ssa-loop-im.c (UNANALYZABLE_MEM_ID): New define. + (MEM_ANALYZABLE): Adjust. + (record_mem_ref_loc): Move bitmap ops ... + (gather_mem_refs_stmt): ... here. Use the shared mem-ref for + unanalyzable refs, do not record locations for it. + (analyze_memory_references): Allocate ref zero as shared + unanalyzable ref. + (refs_independent_p): Do not test for unanalyzed mems here. + (ref_indep_loop_p_1): Special-case disambiguation against + the unanalyzed ref. + (ref_indep_loop_p): Assert we are not queried for the unanalyzed mem. + +2013-03-21 Christophe Lyon <christophe.lyon@linaro.org> + + * config/arm/arm-protos.h (tune_params): Add + prefer_neon_for_64bits field. + * config/arm/arm.c (prefer_neon_for_64bits): New variable. + (arm_slowmul_tune): Default prefer_neon_for_64bits to false. + (arm_fastmul_tune, arm_strongarm_tune, arm_xscale_tune): Ditto. + (arm_9e_tune, arm_v6t2_tune, arm_cortex_tune): Ditto. + (arm_cortex_a15_tune, arm_cortex_a5_tune): Ditto. + (arm_cortex_a9_tune, arm_v6m_tune, arm_fa726te_tune): Ditto. + (arm_option_override): Handle -mneon-for-64bits new option. + * config/arm/arm.h (TARGET_PREFER_NEON_64BITS): New macro. + (prefer_neon_for_64bits): Declare new variable. + * config/arm/arm.md (arch): Rename neon_onlya8 and neon_nota8 to + avoid_neon_for_64bits and neon_for_64bits. Remove onlya8 and nota8. + (arch_enabled): Handle new arch types. Remove support for onlya8 + and nota8. + (one_cmpldi2): Use new arch names. + (zero_extend<mode>di2, extend<mode>di2): Ditto. + * config/arm/arm.opt (mneon-for-64bits): Add option. + * config/arm/neon.md (adddi3_neon, subdi3_neon, iordi3_neon) + (anddi3_neon, xordi3_neon, ashldi3_neon, <shift>di3_neon): Use + neon_for_64bits instead of nota8 and avoid_neon_for_64bits instead + of onlya8. + * doc/invoke.texi (-mneon-for-64bits): Document. + +2013-03-21 Richard Biener <rguenther@suse.de> + + PR tree-optimization/39326 + * tree-ssa-loop-im.c (bb_loop_postorder): New global static. + (sort_bbs_in_loop_postorder_cmp): New function. + (gather_mem_refs_in_loops): Assign mem-ref IDs in loop postorder. + +2013-03-21 Richard Biener <rguenther@suse.de> + + * tree-vect-data-refs.c (vect_update_interleaving_chain): Remove. + (vect_insert_into_interleaving_chain): Likewise. + (vect_drs_dependent_in_basic_block): Inline ... + (vect_slp_analyze_data_ref_dependence): ... here. New function, + split out from ... + (vect_analyze_data_ref_dependence): ... here. Simplify. + (vect_check_interleaving): Simplify. + (vect_analyze_data_ref_dependences): Likewise. Split out ... + (vect_slp_analyze_data_ref_dependences): ... this new function. + (dr_group_sort_cmp): New function. + (vect_analyze_data_ref_accesses): Compute data-reference groups + here instead of in vect_analyze_data_ref_dependence. Use + a more efficient algorithm. + * tree-vect-slp.c (vect_slp_analyze_bb_1): Use + vect_slp_analyze_data_ref_dependences. Call + vect_analyze_data_ref_accesses earlier. + * tree-vect-loop.c (vect_analyze_loop_2): Likewise. + * tree-vectorizer.h (vect_analyze_data_ref_dependences): Adjust. + (vect_slp_analyze_data_ref_dependences): New prototype. + +2013-03-21 Richard Biener <rguenther@suse.de> + + * tree-ssa-loop-im.c (can_sm_ref_p): Do not test whether + ref is stored in the loop. + (find_refs_for_sm): Walk only over all stores. + (store_motion_loop): Allocate from lim_bitmap_obstack. + (store_motion): Likewise. + +2013-03-21 Richard Biener <rguenther@suse.de> + + * tree-vect-loop-manip.c (slpeel_tree_peel_loop_to_edge): + Update virtual SSA form. + +2013-03-21 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> + + * configure.ac (gcc_cv_ld_eh_frame_ciev3): New test. + * configure: Regenerate. + * config.in: Regenerate. + * config/sol2.c (solaris_override_options): Only enforce DWARF 2 + if !HAVE_LD_EH_FRAME_CIEV3. + +2013-03-21 Richard Biener <rguenther@suse.de> + + * tree-cfg.c (verify_expr_no_block): New function. + (verify_expr_location_1): Verify that neither DECL_DEBUG_EXPR + nor DECL_VALUE_EXPR have locations with associated blocks. + * tree-ssa-live.c (clear_unused_block_pointer_1): Remove. + (clear_unused_block_pointer): Remove code dealing with + blocks in DECL_DEBUG_EXPR locations. + +2013-03-21 Richard Biener <rguenther@suse.de> + + * tree.h (DECL_DEBUG_EXPR_IS_FROM): Rename to ... + (DECL_HAS_DEBUG_EXPR_P): ... this. Guard properly. + * tree.c (copy_node_stat): Do not copy DECL_HAS_DEBUG_EXPR_P. + * dwarf2out.c (add_var_loc_to_decl): Use DECL_HAS_DEBUG_EXPR_P + instead of DECL_DEBUG_EXPR_IS_FROM. + * gimplify.c (gimplify_modify_expr): Likewise. + * tree-cfg.c (verify_expr_location_1): Likewise. + * tree-complex.c (create_one_component_var): Likewise. + * tree-sra.c (create_access_replacement): Likewise. + * tree-ssa-live.c (clear_unused_block_pointer_1): Likewise. + (clear_unused_block_pointer): Likewise. + * tree-streamer-in.c (unpack_ts_decl_common_value_fields): Likewise. + * tree-streamer-out.c (pack_ts_decl_common_value_fields): Likewise. + * var-tracking.c (var_debug_decl): Likewise. + (track_expr_p): Likewise. + * tree-inline.c (add_local_variables): Likewise. Set + DECL_HAS_DEBUG_EXPR_P after copying it. + * tree-diagnostic.c (default_tree_printer): Use DECL_HAS_DEBUG_EXPR_P + instead of DECL_DEBUG_EXPR_IS_FROM. Guard properly. + +2013-03-21 Uros Bizjak <ubizjak@gmail.com> + + PR bootstrap/56656 + * configure.ac (HAVE_AS_IX86_INTERUNIT_MOVQ): New test. + * configure: Regenerate. + * config.in: Regenerate. + * config/i386/i386.md (*movdf_internal): Use + HAVE_AS_IX86_INTERUNIT_MOVQ to handle broken assemblers that require + movd instead of movq mnemonic for interunit moves. + (*movdi_internal): Ditto. + +2013-03-21 Naveen H.S <Naveen.Hurugalawadi@caviumnetworks.com> + + * config/aarch64/aarch64-simd.md (simd_fabd): New Attribute. + (abd<mode>_3): New pattern. + (aba<mode>_3): New pattern. + (fabd<mode>_3): New pattern. + +2013-03-21 Naveen H.S <Naveen.Hurugalawadi@caviumnetworks.com> + + * config/aarch64/aarch64-elf.h (REGISTER_PREFIX): Remove. + * config/aarch64/aarch64.c (aarch64_print_operand): Remove all + occurrence of REGISTER_PREFIX as its empty string. + +2013-03-20 Jeff Law <law@redhat.com> + + * tree-ssa-dom.c (record_equivalences_from_incoming_edge): Record + addititional equivalences for equality comparisons between an SSA_NAME + and a constant where the SSA_NAME was set from a widening conversion. + +2013-03-20 Walter Lee <walt@tilera.com> + + * config/tilegx/sync.md (atomic_test_and_set): New pattern. + +2013-03-20 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/i386.md (*movoi_internal_avx): Emit insn template + depending on type attribute. + (*movti_internal): Ditto. + (*movtf_internal): Ditto. + (*movxf_internal): Ditto. + (*movdf_internal): Ditto. + (*movsf_internal): Ditto. + +2013-03-20 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/i386.md (*movti_internal): Set prefix attribute to + maybe_vex for sselog1 and ssemov types. + (*movdi_internal): Reorder operand constraints. + (*movsi_internal): Ditto. Set prefix attribute to + maybe_vex for sselog1 and ssemov types. + (*movtf_internal): Set prefix attribute to maybe_vex + for sselog1 and ssemov types. + (*movdf_internal): Ditto. Set prefix_data16 attribute for + DImode ssemov types. Reorder operand constraints. + (*movsf_internal): Set type of alternatives 3,4 to imov. Set prefix + attribute to maybe_vex for sselog1 and ssemov types. Set prefix_data16 + attribute for SImode ssemov types. Reorder operand constraints. + +2013-03-20 Martin Jambor <mjambor@suse.cz> + + * params.def (PARAM_IPA_CP_ARRAY_INDEX_HINT_BONUS): New parameter. + * ipa-cp.c (hint_time_bonus): Add abonus for known array indices. + +2013-03-20 Pat Haugen <pthaugen@us.ibm.com> + + * config/rs6000/predicates.md (indexed_address, update_address_mem + update_indexed_address_mem): New predicates. + * config/rs6000/vsx.md (vsx_extract_<mode>_zero): Set correct "type" + attribute for load/store instructions. + * config/rs6000/dfp.md (movsd_store): Likewise. + (movsd_load): Likewise. + * config/rs6000/rs6000.md (zero_extend<mode>di2_internal1): Likewise. + (unnamed HI->DI extend define_insn): Likewise. + (unnamed SI->DI extend define_insn): Likewise. + (unnamed QI->SI extend define_insn): Likewise. + (unnamed QI->HI extend define_insn): Likewise. + (unnamed HI->SI extend define_insn): Likewise. + (unnamed HI->SI extend define_insn): Likewise. + (extendsfdf2_fpr): Likewise. + (movsi_internal1): Likewise. + (movsi_internal1_single): Likewise. + (movhi_internal): Likewise. + (movqi_internal): Likewise. + (movcc_internal1): Correct mnemonic for stw insn. Set correct "type" + attribute for load/store instructions. + (mov<mode>_hardfloat): Set correct "type" attribute for load/store + instructions. + (mov<mode>_softfloat): Likewise. + (mov<mode>_hardfloat32): Likewise. + (mov<mode>_hardfloat64): Likewise. + (mov<mode>_softfloat64): Likewise. + (movdi_internal32): Likewise. + (movdi_internal64): Likewise. + (probe_stack_<mode>): Likewise. + +2013-03-20 Michael Meissner <meissner@linux.vnet.ibm.com> + + * config/rs6000/vector.md (VEC_R): Add 32-bit integer, binary + floating point, and decimal floating point to reload iterator. + + * config/rs6000/constraints.md (wl constraint): New constraints to + return FLOAT_REGS if certain options are used to reduce the number + of separate patterns that exist in the file. + (wx constraint): Likewise. + (wz constraint): Likewise. + + * config/rs6000/rs6000.c (rs6000_debug_reg_global): If + -mdebug=reg, print wg, wl, wx, and wz constraints. + (rs6000_init_hard_regno_mode_ok): Initialize new constraints. + Initialize the reload functions for 64-bit binary/decimal floating + point types. + (reg_offset_addressing_ok_p): If we are on a power7 or later, use + LFIWZX and STFIWX to load/store 32-bit decimal types, and don't + create the buffer on the stack to overcome not having a 32-bit + load and store. + (rs6000_emit_move): Likewise. + (rs6000_secondary_memory_needed_rtx): Likewise. + (rs6000_alloc_sdmode_stack_slot): Likewise. + (rs6000_preferred_reload_class): On VSX, we can create SFmode 0.0f + via xxlxor, just like DFmode 0.0. + + * config/rs6000/rs6000.h (TARGET_NO_SDMODE_STACK): New macro, + define as 1 if we are running on a power7 or newer. + (enum r6000_reg_class_enum): Add new constraints. + + * config/rs6000/dfp.md (movsd): Delete, combine with binary + floating point moves in rs6000.md. Combine power6x (mfpgpr) moves + with other moves by using conditional constraits (wg). Use LFIWZX + and STFIWX for loading SDmode on power7. Use xxlxor to create 0.0f. + (movsd splitter): Likewise. + (movsd_hardfloat): Likewise. + (movsd_softfloat): Likewise. + + * config/rs6000/rs6000.md (FMOVE32): New iterators to combine + binary and decimal floating point moves. + (fmove_ok): New attributes to combine binary and decimal floating + point moves, and to combine power6x (mfpgpr) moves along normal + floating moves. + (real_value_to_target): Likewise. + (f32_lr): Likewise. + (f32_lm): Likewise. + (f32_li): Likewise. + (f32_sr): Likewise. + (f32_sm): Likewise. + (f32_si): Likewise. + (movsf): Combine binary and decimal floating point moves. Combine + power6x (mfpgpr) moves with other moves by using conditional + constraits (wg). Use LFIWZX and STFIWX for loading SDmode on power7. + (mov<mode> for SFmode/SDmode); Likewise. + (SFmode/SDmode splitters): Likewise. + (movsf_hardfloat): Likewise. + (mov<mode>_hardfloat for SFmode/SDmode): Likewise. + (movsf_softfloat): Likewise. + (mov<mode>_softfloat for SFmode/SDmode): Likewise. + + * doc/md.texi (PowerPC and IBM RS6000 constraints): Document wl, + wx and wz constraints. + + * config/rs6000/constraints.md (wg constraint): New constraint to + return FLOAT_REGS if -mmfpgpr (power6x) was used. + + * config/rs6000/rs6000.h (enum r6000_reg_class_enum): Add wg + constraint. + + * config/rs6000/rs6000.c (rs6000_debug_reg_global): If + -mdebug=reg, print wg, wl, wx, and wz constraints. + (rs6000_init_hard_regno_mode_ok): Initialize new constraints. + Initialize the reload functions for 64-bit binary/decimal floating + point types. + (reg_offset_addressing_ok_p): If we are on a power7 or later, use + LFIWZX and STFIWX to load/store 32-bit decimal types, and don't + create the buffer on the stack to overcome not having a 32-bit + load and store. + (rs6000_emit_move): Likewise. + (rs6000_secondary_memory_needed_rtx): Likewise. + (rs6000_alloc_sdmode_stack_slot): Likewise. + (rs6000_preferred_reload_class): On VSX, we can create SFmode 0.0f + via xxlxor, just like DFmode 0.0. + + * config/rs6000/dfp.md (movdd): Delete, combine with binary + floating point moves in rs6000.md. Combine power6x (mfpgpr) moves + with other moves by using conditional constraits (wg). Use LFIWZX + and STFIWX for loading SDmode on power7. + (movdd splitters): Likewise. + (movdd_hardfloat32): Likewise. + (movdd_softfloat32): Likewise. + (movdd_hardfloat64_mfpgpr): Likewise. + (movdd_hardfloat64): Likewise. + (movdd_softfloat64): Likewise. + + * config/rs6000/rs6000.md (FMOVE64): New iterators to combine + 64-bit binary and decimal floating point moves. + (FMOVE64X): Likewise. + (movdf): Combine 64-bit binary and decimal floating point moves. + Combine power6x (mfpgpr) moves with other moves by using + conditional constraits (wg). + (mov<mode> for DFmode/DDmode): Likewise. + (DFmode/DDmode splitters): Likewise. + (movdf_hardfloat32): Likewise. + (mov<mode>_hardfloat32 for DFmode/DDmode): Likewise. + (movdf_softfloat32): Likewise. + (movdf_hardfloat64_mfpgpr): Likewise. + (movdf_hardfloat64): Likewise. + (mov<mode>_hardfloat64 for DFmode/DDmode): Likewise. + (movdf_softfloat64): Likewise. + (mov<mode>_softfloat64 for DFmode/DDmode): Likewise. + (reload_<mode>_load): Move to later in the file so they aren't in + the middle of the floating point move insns. + (reload_<mode>_store): Likewise. + + * doc/md.texi (PowerPC and IBM RS6000 constraints): Document wg + constraint. + + * config/rs6000/rs6000.c (rs6000_debug_reg_global): Print out wg + constraint if -mdebug=reg. + (rs6000_initi_hard_regno_mode_ok): Enable wg constraint if -mfpgpr. + Enable using dd reload support if needed. + + * config/rs6000/dfp.md (movtd): Delete, combine with 128-bit + binary and decimal floating point moves in rs6000.md. + (movtd_internal): Likewise. + + * config/rs6000/rs6000.md (FMOVE128): Combine 128-bit binary and + decimal floating point moves. + (movtf): Likewise. + (movtf_internal): Likewise. + (mov<mode>_internal, TDmode/TFmode): Likewise. + (movtf_softfloat): Likewise. + (mov<mode>_softfloat, TDmode/TFmode): Likewise. + + * config/rs6000/rs6000.md (movdi_mfpgpr): Delete, combine with + movdi_internal64, using wg constraint for move direct operations. + (movdi_internal64): Likewise. + + * config/rs6000/rs6000.c (rs6000_debug_reg_global): Print + MODES_TIEABLE_P for selected modes. Print the numerical value of + the various virtual registers. Use GPR/FPR first/last values, + instead of hard coding the register numbers. Print which modes + have reload functions registered. + (rs6000_option_override_internal): If -mdebug=reg, trace the options + settings before/after setting cpu, target and subtarget settings. + (rs6000_secondary_reload_trace): Improve the RTL dump for -mdebug=addr + and for secondary reload failures in rs6000_secondary_reload_inner. + (rs6000_secondary_reload_fail): Likewise. + (rs6000_secondary_reload_inner): Likewise. + + * config/rs6000/rs6000.md (FIRST_GPR_REGNO): Add convenience + macros for first/last GPR and FPR registers. + (LAST_GPR_REGNO): Likewise. + (FIRST_FPR_REGNO): Likewise. + (LAST_FPR_REGNO): Likewise. + + * config/rs6000/vector.md (mul<mode>3): Use the combined macro + VECTOR_UNIT_ALTIVEC_OR_VSX_P instead of separate calls to + VECTOR_UNIT_ALTIVEC_P and VECTOR_UNIT_VSX_P. + (vcond<mode><mode>): Likewise. + (vcondu<mode><mode>): Likewise. + (vector_gtu<mode>): Likewise. + (vector_gte<mode>): Likewise. + (xor<mode>3): Don't allow logical operations on TImode in 32-bit + to prevent the compiler from converting DImode operations to TImode. + (ior<mode>3): Likewise. + (and<mode>3): Likewise. + (one_cmpl<mode>2): Likewise. + (nor<mode>3): Likewise. + (andc<mode>3): Likewise. + + * config/rs6000/constraints.md (wt constraint): New constraint + that returns VSX_REGS if TImode is allowed in VSX registers. + + * config/rs6000/predicates.md (easy_fp_constant): 0.0f is an easy + constant under VSX. + + * config/rs6000/rs6000-modes.def (PTImode): Define, PTImode is + similar to TImode, but it is restricted to being in the GPRs. + + * config/rs6000/rs6000.opt (-mvsx-timode): New switch to allow + TImode to occupy a single VSX register. + + * config/rs6000/rs6000-cpus.def (ISA_2_6_MASKS_SERVER): Default to + -mvsx-timode for power7/power8. + (power7 cpu): Likewise. + (power8 cpu): Likewise. + + * config/rs6000/rs6000.c (rs6000_hard_regno_nregs_internal): Make + sure that TFmode/TDmode take up two registers if they are ever + allowed in the upper VSX registers. + (rs6000_hard_regno_mode_ok): If -mvsx-timode, allow TImode in VSX + registers. + (rs6000_init_hard_regno_mode_ok): Likewise. + (rs6000_debug_reg_global): Add debugging for PTImode and wt + constraint. Print if LRA is turned on. + (rs6000_option_override_internal): Give an error if -mvsx-timode + and VSX is not enabled. + (invalid_e500_subreg): Handle PTImode, restricting it to GPRs. If + -mvsx-timode, restrict TImode to reg+reg addressing, and PTImode + to reg+offset addressing. Use PTImode when checking offset + addresses for validity. + (reg_offset_addressing_ok_p): Likewise. + (rs6000_legitimate_offset_address_p): Likewise. + (rs6000_legitimize_address): Likewise. + (rs6000_legitimize_reload_address): Likewise. + (rs6000_legitimate_address_p): Likewise. + (rs6000_eliminate_indexed_memrefs): Likewise. + (rs6000_emit_move): Likewise. + (rs6000_secondary_reload): Likewise. + (rs6000_secondary_reload_inner): Handle PTImode. Allow 64-bit + reloads to fpr registers to continue to use reg+offset addressing, + but 64-bit reloads to altivec registers need reg+reg addressing. + Drop test for PRE_MODIFY, since VSX loads/stores no longer support + it. Treat LO_SUM like a PLUS operation. + (rs6000_secondary_reload_class): If type is 64-bit, prefer to use + FLOAT_REGS instead of VSX_RGS to allow use of reg+offset addressing. + (rs6000_cannot_change_mode_class): Do not allow TImode in VSX + registers to share a register with a smaller sized type, since VSX + puts scalars in the upper 64-bits. + (print_operand): Add support for PTImode. + (rs6000_register_move_cost): Use VECTOR_MEM_VSX_P instead of + VECTOR_UNIT_VSX_P to catch types that can be loaded in VSX + registers, but don't have arithmetic support. + (rs6000_memory_move_cost): Add test for VSX. + (rs6000_opt_masks): Add -mvsx-timode. + + * config/rs6000/vsx.md (VSm): Change to use 64-bit aligned moves + for TImode. + (VSs): Likewise. + (VSr): Use wt constraint for TImode. + (VSv): Drop TImode support. + (vsx_movti): Delete, replace with versions for 32-bit and 64-bit. + (vsx_movti_64bit): Likewise. + (vsx_movti_32bit): Likewise. + (vec_store_<mode>): Use VSX iterator instead of vector iterator. + (vsx_and<mode>3): Delete use of '?' constraint on inputs, just put + one '?' on the appropriate output constraint. Do not allow TImode + logical operations on 32-bit systems. + (vsx_ior<mode>3): Likewise. + (vsx_xor<mode>3): Likewise. + (vsx_one_cmpl<mode>2): Likewise. + (vsx_nor<mode>3): Likewise. + (vsx_andc<mode>3): Likewise. + (vsx_concat_<mode>): Likewise. + (vsx_xxpermdi_<mode>): Fix thinko for non V2DF/V2DI modes. + + * config/rs6000/rs6000.h (MASK_VSX_TIMODE): Map from + OPTION_MASK_VSX_TIMODE. + (enum rs6000_reg_class_enum): Add RS6000_CONSTRAINT_wt. + (STACK_SAVEAREA_MODE): Use PTImode instead of TImode. + + * config/rs6000/rs6000.md (INT mode attribute): Add PTImode. + (TI2 iterator): New iterator for TImode, PTImode. + (wd mode attribute): Add values for vector types. + (movti_string): Replace TI move operations with operations for TImode + and PTImode. Add support for TImode being allowed in VSX registers. + (mov<mode>_string, TImode/PTImode): Likewise. + (movti_ppc64): Likewise. + (mov<mode>_ppc64, TImode/PTImode): Likewise. + (TI mode splitters): Likewise. + + * doc/md.texi (PowerPC and IBM RS6000 constraints): Document wt + constraint. + +2013-03-20 Marc Glisse <marc.glisse@inria.fr> + + PR tree-optimization/56355 + * fold-const.c (tree_binary_nonnegative_warnv_p) <MULT_EXPR>: + Also handle integers with undefined overflow. + +2013-03-20 Catherine Moore <clm@codesourcery.com> + Maciej W. Rozycki <macro@codesourcery.com> + Tom de Vries <tom@codesourcery.com> + Nathan Sidwell <nathan@codesourcery.com> + 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. + * doc/invoke.texi (minterlink-compressed, mmicromips, + m14k, m14ke, m14kec): Document new options. + (minterlink-mips16): Update documentation. + * doc/md.texi (ZC, ZD): Document new constraints. + * configure.ac (gcc_cv_as_micromips): Check if linker + supports the .set micromips directive. + * configure: Regenerate. + * config.in: Regenerate. + * config/mips/mips-tables.opt: Regenerate. + * config/mips/micromips.md: New file. + * constraints.md (ZC, ZD): New constraints. + * config/mips/predicates.md (movep_src_register): New predicate. + (movep_src_operand): New predicate. + (non_volatile_mem_operand): New predicate. + * config/mips/mips.md (multimem): New type. + (length): Differentiate between 17-bit and 18-bit branch offsets. + (MOVEP1, MOVEP2): New mode iterator. + (mov_<load>l): Use ZC constraint. + (mov_<load>r): Likewise. + (mov_<store>l): Likewise. + (mov_<store>r): Likewise. + (*branch_equality<mode>_inverted): Add microMIPS support. + (*branch_equality<mode>): Likewise. + (*jump_absolute): Likewise. + (indirect_jump_<mode>): Likewise. + (tablejump_<mode>): Likewise. + (<optab>_internal): Likewise. + (sibcall_internal): Likewise. + (sibcall_value_internal): Likewise. + (prefetch): Use constraint ZD. + * config/mips/mips.opt (minterlink-compressed): New option. + (minterlink-mips16): Now an alias for minterlink-compressed. + (mmicromips): New option. + * config/mips/sync.md (sync_compare_and_swap<mode>): Use ZR constraint. + (compare_and_swap_12): Likewise. + (sync_add<mode>): Likewise. + (sync_<optab>_12): Likewise. + (sync_old_<optab>_12): Likewise. + (sync_new_<optab>_12): Likewise. + (sync_nand_12): Likewise. + (sync_old_nand_12): Likewise. + (sync_new_nand_12): Likewise. + (sync_sub<mode>): Likewise. + (sync_old_add<mode>): Likewise. + (sync_old_sub<mode>): Likewise. + (sync_new_add<mode>): Likewise. + (sync_new_sub<mode>): Likewise. + (sync_<optab><mode>): Likewise. + (sync_old_<optab><mode>): Likewise. + (sync_new_<optab><mode>): Likewise. + (sync_nand<mode>): Likewise. + (sync_old_nand<mode>): Likewise. + (sync_new_nand<mode>): Likewise. + (sync_lock_test_and_set<mode>): Likewise. + (test_and_set_12): Likewise. + (atomic_compare_and_swap<mode>): Likewise. + (atomic_exchange<mode>_llsc): Likewise. + (atomic_fetch_add<mode>_llsc): Likewise. + * config/mips/mips-cpus.def (m14kc, m14k): New processors. + * config/mips/mips-protos.h (umips_output_save_restore): New prototype. + (umips_save_restore_pattern_p): Likewise. + (umips_load_store_pair_p): Likewise. + (umips_output_load_store_pair): Likewise. + (umips_movep_target_p): Likewise. + (umips_12bit_offset_address_p): Likewise. + * config/mips/mips.c (MIPS_MAX_FIRST_STEP): Update for microMIPS. + (mips_base_mips16): Rename this... + (mips_base_compression_flags): ...to this. Update all uses. + (mips_attribute_table): Add micromips, nomicromips and nocompression. + (mips_mips16_decl_p): Delete. + (mips_nomips16_decl_p): Delete. + (mips_get_compress_on_flags): New function. + (mips_get_compress_off_flags): New function. + (mips_get_compress_mode): New function. + (mips_get_compress_on_name): New function. + (mips_get_compress_off_name): New function. + (mips_insert_attributes): Support multiple compression types. + (mips_merge_decl_attributes): Likewise. + (umips_12bit_offset_address_p): New function. + (mips_start_function_definition): Emit .set micromips directive. + (mips_call_may_need_jalx_p): New function. + (mips_function_ok_for_sibcall): Add microMIPS support. + (mips_print_operand_punctuation): Support short delay slots and + compact jumps. + (umips_swm_mask, umips_swm_encoding): New. + (umips_build_save_restore): New function. + (mips_for_each_saved_gpr_and_fpr): Add microMIPS support. + (was_mips16_p): Remove. + (old_compression_mode): New. + (mips_set_compression_mode): New function. + (mips_set_current_function): Add microMIPS support. + (mips_option_override): Likewise. + (umips_save_restore_pattern_p): New function. + (umips_output_save_restore): New function. + (umips_load_store_pair_p_1): New function. + (umips_load_store_pair_p): New function. + (umips_output_load_store_pair_1): New function. + (umips_output_load_store_pair): New function. + (umips_movep_target_p) New function. + (mips_prepare_pch_save): Add microMIPS support. + * config/mips/mips.h (TARGET_COMPRESSION): New. + (TARGET_CPU_CPP_BUILTINS): Update macro + to use new compression flags and to support microMIPS. + (MIPS_ISA_LEVEL_SPEC): Add m14k processors. + (MIPS_ARCH_FLOAT_SPEC): Likewise. + (ISA_HAS_LWXS): Include TARGET_MICROMIPS. + (ISA_HAS_LOAD_DELAY): Exclude TARGET_MICROMIPS. + (ASM_SPEC): Support mmicromips and mno-micromips. + (M16STORE_REG_P): New macro. + (MIPS_CALL): Support TARGET_MICROMIPS. + (MICROMIPS_J): New macro. + (mips_base_mips16): Rename this... + (mips_base_compression_flags): ...to this. + (UMIPS_12BIT_OFFSET_P): New macro. + * config/mips/t-sde: (MULTILIB_OPTIONS): Add microMIPS. + (MULTILIB_DIRNAMES): Likewise. +2013-03-20 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56661 + * tree-ssa-sccvn.c (visit_use): Only value-number calls if + the result does not have to be distinct. + +2013-03-20 Richard Biener <rguenther@suse.de> + + * tree-inline.c (copy_tree_body_r): Sync MEM_REF code with + remap_gimple_op_r. + +2013-03-20 Bill Schmidt <wschmidt@linux.vnet.ibm.com> + Steven Bosscher <steven@gcc.gnu.org> + + PR rtl-optimization/56605 + * loop-iv.c (implies_p): Handle equal RTXs and subregs. + +2013-03-20 Uros Bizjak <ubizjak@gmail.com> + + PR bootstrap/56656 + * config/i386/i386.md (*movdi_internal): Handle broken assemblers + that require movd instead of movq. + +2013-03-20 Richard Biener <rguenther@suse.de> + + * tree-ssa-structalias.c (struct variable_info): Add pointer + to the first field of an aggregate with sub-vars. Make + this and the pointer to the next subfield its ID. + (vi_next): New function. + (nothing_id, anything_id, readonly_id, escaped_id, nonlocal_id, + storedanything_id, integer_id): Increment by one. + (new_var_info, get_call_vi, lookup_call_clobber_vi, + get_call_clobber_vi): Adjust. + (solution_set_expand): Simplify and speedup. + (solution_set_add): Inline into ... + (set_union_with_increment): ... this. Adjust accordingly. + (do_sd_constraint): Likewise. + (do_ds_constraint): Likewise. + (do_complex_constraint): Simplify. + (build_pred_graph): Adjust. + (solve_graph): Likewise. Simplify and speedup. + (get_constraint_for_ssa_var, get_constraint_for_ptr_offset, + get_constraint_for_component_ref, get_constraint_for_1, + first_vi_for_offset, first_or_preceding_vi_for_offset, + create_function_info_for, create_variable_info_for_1, + create_variable_info_for, intra_create_variable_infos): Adjust. + (init_base_vars): Push NULL for ID zero. + (compute_points_to_sets): Adjust. + +2013-03-20 Richard Biener <rguenther@suse.de> + + * cfgloop.c (verify_loop_structure): Streamline and avoid + ICEing on corrupt loop tree. + * graph.c (draw_cfg_nodes_for_loop): Avoid ICEing on corrupt + loop tree. + +2013-03-20 Richard Biener <rguenther@suse.de> + + * tree-vect-loop-manip.c (slpeel_can_duplicate_loop_p): Do not + check whether an SSA update is needed. + +2013-03-20 Richard Sandiford <rdsandiford@googlemail.com> + + * config/mips/constraints.md (T): Rename to... + (Yf): ...this. + (U): Rename to... + (Yd): ...this. + * config/mips/mips.md (*movdi_64bit, *movdi_64bit_mips16) + (*mov<mode>_internal, *mov<mode>_mips16): Update accordingly. + +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 + * doc/extend.texi: Document __ATOMIC_HLE_ACQUIRE, + __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> + + * 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. + (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. + (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_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. + (TARGET_CANNOT_FORCE_CONST_MEM): Define. + * config/microblaze/microblaze.h (TLS_NEEDS_GOT): Define + (PIC_OFFSET_TABLE_REGNUM): Set. + * config/microblaze/linux.h (TLS_NEEDS_GOT): Define. + * 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. + +2013-03-14 Ian Bolton <ian.bolton@arm.com> + + * config/aarch64/aarch64.md: (*and<mode>3nr_compare0): Use CC_NZ. + (*and_<SHIFT:optab><mode>3nr_compare0): Likewise. + +2013-03-14 Ian Bolton <ian.bolton@arm.com> + + * config/aarch64/aarch64.c (aarch64_select_cc_mode): Return correct + CC mode for AND. + +2013-03-14 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/53265 + * common.opt (Waggressive-loop-optimizations): New option. + * tree-ssa-loop-niter.c: Include tree-pass.h. + (do_warn_aggressive_loop_optimizations): New function. + (record_estimate): Call it. Don't add !is_exit bounds to loop->bounds + if number_of_latch_executions returned constant. + (estimate_numbers_of_iterations_loop): Call number_of_latch_executions + early. If number_of_latch_executions returned constant, set + nb_iterations_upper_bound back to it. + * cfgloop.h (struct loop): Add warned_aggressive_loop_optimizations + field. + * Makefile.in (tree-ssa-loop-niter.o): Depend on $(TREE_PASS_H). + * doc/invoke.texi (-Wno-aggressive-loop-optimizations): Document. + + * config/aarch64/t-aarch64-linux (MULTARCH_DIRNAME): Remove. + (MULTILIB_OSDIRNAMES): Set. + * genmultilib: If defaultosdirname doesn't start with :: , set + defaultosdirname2 instead, clear it and emit two . multilib_raw + entries instead of just one. + +2013-03-14 Kaz Kojima <kkojima@gcc.gnu.org> + + * config/sh/linux.h (TARGET_DEFAULT): Remove MASK_USERMODE. + (SUBTARGET_OVERRIDE_OPTIONS): Set TARGET_USERMODE as default. + * config/sh/netbsd-elf.h (TARGET_DEFAULT): Remove MASK_USERMODE. + (SUBTARGET_OVERRIDE_OPTIONS): New. + +2013-03-13 Oleg Endo <olegendo@gcc.gnu.org> + + PR target/49880 + * config/sh/sh.opt (FPU_SINGLE_ONLY): New mask. + (musermode): Convert to Var(TARGET_USERMODE). + * config/sh/sh.h (SELECT_SH2A_SINGLE_ONLY, SELECT_SH4_SINGLE_ONLY, + MASK_ARCH): Add MASK_FPU_SINGLE_ONLY. + * config/sh/sh.c (sh_option_override): Use + TARGET_FPU_DOUBLE || TARGET_FPU_SINGLE_ONLY for call-fp case. + * config/sh/sh.md (udivsi3_i1, divsi3_i1): Remove ! TARGET_SH4 + condition. + (udivsi3_i4, divsi3_i4): Use TARGET_FPU_DOUBLE condition instead of + TARGET_SH4. + (udivsi3_i4_single, divsi3_i4_single): Use + TARGET_FPU_SINGLE_ONLY || TARGET_FPU_DOUBLE instead of TARGET_HARD_SH4. + +2013-03-13 Dave Korn <dave.korn.cygwin@....> + + * config/i386/cygwin.h (SHARED_LIBGCC_SPEC): Make shared libgcc the + default setting. + +2013-03-13 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56608 + * tree-vect-slp.c (vect_schedule_slp): Do not remove scalar + calls when vectorizing basic-blocks. + +2013-03-13 Jakub Jelinek <jakub@redhat.com> + + PR plugins/45078 + * config.gcc: On arm, mips, sh and sparc add vxworks-dummy.h to + tm_file. + +2013-03-12 Jakub Jelinek <jakub@redhat.com> + + * doc/invoke.texi (-Waddr-space-convert): Move into the table earlier. + +2013-03-11 Jan Hubicka <jh@suse.cz> + + PR lto/56557 + * lto-streamer-out.c (output_symbol_p): Skip references from + constructors of external variables. + +2013-03-11 Jan Hubicka <jh@suse.cz> + + PR middle-end/56571 + * valtrack.c (cleanup_auto_inc_dec): Unshare clobbers originating + from pseudos. + * emit-rtl.c (verify_rtx_sharing): Likewise. + (copy_insn_1): Likewise. + * rtl.c (copy_rtx): Likewise. + 2013-03-11 Georg-Johann Lay <avr@gjlay.de> 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 @@ -348,9 +1674,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. @@ -402,8 +1728,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> @@ -573,8 +1899,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 @@ -690,8 +2015,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> @@ -735,8 +2059,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. @@ -886,7 +2211,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. @@ -1121,8 +2446,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> @@ -1133,8 +2458,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 @@ -1143,8 +2467,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> @@ -1153,7 +2476,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. @@ -1190,7 +2513,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 @@ -1208,11 +2531,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> @@ -1243,8 +2565,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. @@ -1268,8 +2589,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 @@ -1310,18 +2631,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' @@ -1411,13 +2731,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 a32a2452be8..6280d60defd 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20130311 +20130325 diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 52a5c432c05..83f9a63ffe2 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -2449,7 +2449,7 @@ tree-ssa-loop-niter.o : tree-ssa-loop-niter.c $(TREE_FLOW_H) $(CONFIG_H) \ $(SYSTEM_H) $(TREE_H) $(TM_P_H) $(CFGLOOP_H) $(PARAMS_H) \ $(TREE_INLINE_H) $(DIAGNOSTIC_H) $(TM_H) coretypes.h dumpfile.h \ $(DIAGNOSTIC_CORE_H) $(FLAGS_H) $(TREE_DATA_REF_H) \ - $(BASIC_BLOCK_H) $(GGC_H) intl.h $(GIMPLE_PRETTY_PRINT_H) + $(BASIC_BLOCK_H) $(GGC_H) intl.h $(GIMPLE_PRETTY_PRINT_H) $(TREE_PASS_H) tree-ssa-loop-ivcanon.o : tree-ssa-loop-ivcanon.c $(TREE_FLOW_H) $(CONFIG_H) \ $(SYSTEM_H) $(TREE_H) $(TM_P_H) $(CFGLOOP_H) $(PARAMS_H) \ $(TREE_INLINE_H) $(DIAGNOSTIC_H) $(TM_H) coretypes.h \ diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 784448558ad..3ec3e291cae 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,12 @@ +2013-03-20 Tobias Burnus <burnus@net-b.de> + + * i-fortra.ads: Update comment, add Ada 2012's optional + Star and Kind data types for enhanced interoperability. + +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/ada/i-fortra.ads b/gcc/ada/i-fortra.ads index 992eb28634c..0946e49a7e3 100644 --- a/gcc/ada/i-fortra.ads +++ b/gcc/ada/i-fortra.ads @@ -26,11 +26,11 @@ package Interfaces.Fortran is type Logical is new Boolean; for Logical'Size use Integer'Size; pragma Convention (Fortran, Logical); - -- As required by Fortran standard, stand alone logical allocates same - -- space as integer (but what about the array case???). The convention - -- is important, since in Fortran, Booleans have zero/non-zero semantics - -- for False/True, and the pragma Convention (Fortran) activates the - -- special handling required in this case. + -- As required by Fortran standard, logical allocates same space as + -- an integer. The convention is important, since in Fortran, Booleans + -- are implemented with zero/non-zero semantics for False/True, and the + -- pragma Convention (Fortran) activates the special handling required + -- in this case. package Single_Precision_Complex_Types is new Ada.Numerics.Generic_Complex_Types (Real); @@ -50,6 +50,60 @@ package Interfaces.Fortran is type Fortran_Character is array (Positive range <>) of Character_Set; + -- Additional declarations as permitted by Ada 2012, p.608, paragraph 21. + -- Interoperability with Fortran 77's vendor extension using star + -- notation and Fortran 90's intrinsic types with kind=n parameter. + -- The following assumes that `n' matches the byte size, which + -- most Fortran compiler, including GCC's follow. + + type Integer_Star_1 is new Integer_8; + type Integer_Kind_1 is new Integer_8; + type Integer_Star_2 is new Integer_16; + type Integer_Kind_2 is new Integer_16; + type Integer_Star_4 is new Integer_32; + type Integer_Kind_4 is new Integer_32; + type Integer_Star_8 is new Integer_64; + type Integer_Kind_8 is new Integer_64; + + type Logical_Star_1 is new Boolean; + type Logical_Star_2 is new Boolean; + type Logical_Star_4 is new Boolean; + type Logical_Star_8 is new Boolean; + type Logical_Kind_1 is new Boolean; + type Logical_Kind_2 is new Boolean; + type Logical_Kind_4 is new Boolean; + type Logical_Kind_8 is new Boolean; + for Logical_Star_1'Size use Integer_8'Size; + for Logical_Star_2'Size use Integer_16'Size; + for Logical_Star_4'Size use Integer_32'Size; + for Logical_Star_8'Size use Integer_64'Size; + for Logical_Kind_1'Size use Integer_8'Size; + for Logical_Kind_2'Size use Integer_16'Size; + for Logical_Kind_4'Size use Integer_32'Size; + for Logical_Kind_8'Size use Integer_64'Size; + pragma Convention (Fortran, Logical_Star_1); + pragma Convention (Fortran, Logical_Star_2); + pragma Convention (Fortran, Logical_Star_4); + pragma Convention (Fortran, Logical_Star_8); + pragma Convention (Fortran, Logical_Kind_1); + pragma Convention (Fortran, Logical_Kind_2); + pragma Convention (Fortran, Logical_Kind_4); + pragma Convention (Fortran, Logical_Kind_8); + + type Real_Star_4 is new Float; + type Real_Kind_4 is new Float; + type Real_Star_8 is new Long_Float; + type Real_Kind_8 is new Long_Float; + + -- In the kind syntax, n is the same as the associated real kind. + -- In the star syntax, n is twice as large (real+imaginary size) + type Complex_Star_8 is new Complex; + type Complex_Kind_4 is new Complex; + type Complex_Star_16 is new Double_Complex; + type Complex_Kind_8 is new Double_Complex; + + type Character_Kind_n is new Fortran_Character; + function To_Fortran (Item : Character) return Character_Set; function To_Ada (Item : Character_Set) return Character; diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index 4c8e455e9d2..a76fb3e8862 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,8 @@ +2013-03-21 Richard Biener <rguenther@suse.de> + + * c-objc-common.c (c_tree_printer): Use DECL_HAS_DEBUG_EXPR_P + instead of DECL_DEBUG_EXPR_IS_FROM. Guard properly. + 2013-02-12 Marek Polacek <polacek@redhat.com> PR c/44938 diff --git a/gcc/c/c-objc-common.c b/gcc/c/c-objc-common.c index 6020c028da4..8e73856ac18 100644 --- a/gcc/c/c-objc-common.c +++ b/gcc/c/c-objc-common.c @@ -112,7 +112,7 @@ c_tree_printer (pretty_printer *pp, text_info *text, const char *spec, switch (*spec) { case 'D': - if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t)) + if (TREE_CODE (t) == VAR_DECL && DECL_HAS_DEBUG_EXPR_P (t)) { t = DECL_DEBUG_EXPR (t); if (!DECL_P (t)) diff --git a/gcc/calls.c b/gcc/calls.c index dd034b40099..cdab8e04617 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -3171,7 +3171,9 @@ expand_call (tree exp, rtx target, int ignore) group load/store machinery below. */ if (!structure_value_addr && !pcc_struct_value + && TYPE_MODE (rettype) != VOIDmode && TYPE_MODE (rettype) != BLKmode + && REG_P (valreg) && targetm.calls.return_in_msb (rettype)) { if (shift_return_value (TYPE_MODE (rettype), false, valreg)) @@ -3186,7 +3188,7 @@ expand_call (tree exp, rtx target, int ignore) /* The return value from a malloc-like function is a pointer. */ if (TREE_CODE (rettype) == POINTER_TYPE) - mark_reg_pointer (temp, BIGGEST_ALIGNMENT); + mark_reg_pointer (temp, MALLOC_ABI_ALIGNMENT); emit_move_insn (temp, valreg); diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index 5acc42d73f5..771b019c65b 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); @@ -4853,7 +4858,8 @@ struct rtl_opt_pass pass_expand = 0, /* static_pass_number */ TV_EXPAND, /* tv_id */ PROP_ssa | PROP_gimple_leh | PROP_cfg - | PROP_gimple_lcx, /* properties_required */ + | PROP_gimple_lcx + | PROP_gimple_lvec, /* properties_required */ PROP_rtl, /* properties_provided */ PROP_ssa | PROP_trees, /* properties_destroyed */ TODO_verify_ssa | TODO_verify_flow diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c index 751da5a2c17..54ce2a24c21 100644 --- a/gcc/cfgloop.c +++ b/gcc/cfgloop.c @@ -1319,7 +1319,7 @@ verify_loop_structure (void) { unsigned *sizes, i, j; sbitmap irreds; - basic_block bb; + basic_block bb, *bbs; struct loop *loop; int err = 0; edge e; @@ -1335,43 +1335,51 @@ verify_loop_structure (void) else verify_dominators (CDI_DOMINATORS); - /* Check sizes. */ - sizes = XCNEWVEC (unsigned, num); - sizes[0] = 2; - - FOR_EACH_BB (bb) - for (loop = bb->loop_father; loop; loop = loop_outer (loop)) - sizes[loop->num]++; - - FOR_EACH_LOOP (li, loop, LI_INCLUDE_ROOT) - { - i = loop->num; - - if (loop->num_nodes != sizes[i]) - { - error ("size of loop %d should be %d, not %d", - i, sizes[i], loop->num_nodes); - err = 1; - } - } - /* Check the headers. */ FOR_EACH_BB (bb) - if (bb_loop_header_p (bb) - && bb->loop_father->header != bb) + if (bb_loop_header_p (bb)) { - error ("loop with header %d not in loop tree", bb->index); + if (bb->loop_father->header == NULL) + { + error ("loop with header %d marked for removal", bb->index); + err = 1; + } + else if (bb->loop_father->header != bb) + { + error ("loop with header %d not in loop tree", bb->index); + err = 1; + } + } + else if (bb->loop_father->header == bb) + { + error ("non-loop with header %d not marked for removal", bb->index); err = 1; } - /* Check get_loop_body. */ + /* Check the recorded loop father and sizes of loops. */ visited = sbitmap_alloc (last_basic_block); bitmap_clear (visited); + bbs = XNEWVEC (basic_block, n_basic_blocks); FOR_EACH_LOOP (li, loop, LI_FROM_INNERMOST) { - basic_block *bbs = get_loop_body (loop); + unsigned n; - for (j = 0; j < loop->num_nodes; j++) + if (loop->header == NULL) + { + error ("removed loop %d in loop tree", loop->num); + err = 1; + continue; + } + + n = get_loop_body_with_size (loop, bbs, n_basic_blocks); + if (loop->num_nodes != n) + { + error ("size of loop %d should be %d, not %d", + loop->num, n, loop->num_nodes); + err = 1; + } + + for (j = 0; j < n; j++) { bb = bbs[j]; @@ -1394,16 +1402,16 @@ verify_loop_structure (void) err = 1; } } - - free (bbs); } + free (bbs); sbitmap_free (visited); /* Check headers and latches. */ FOR_EACH_LOOP (li, loop, 0) { i = loop->num; - + if (loop->header == NULL) + continue; if (!bb_loop_header_p (loop->header)) { error ("loop %d%'s header is not a loop header", i); @@ -1561,6 +1569,7 @@ verify_loop_structure (void) { unsigned n_exits = 0, eloops; + sizes = XCNEWVEC (unsigned, num); memset (sizes, 0, sizeof (unsigned) * num); FOR_EACH_BB (bb) { @@ -1624,11 +1633,12 @@ verify_loop_structure (void) err = 1; } } + + free (sizes); } gcc_assert (!err); - free (sizes); if (!dom_available) free_dominance_info (CDI_DOMINATORS); } diff --git a/gcc/cfgloop.h b/gcc/cfgloop.h index 0b2af724e10..01cef519a0c 100644 --- a/gcc/cfgloop.h +++ b/gcc/cfgloop.h @@ -159,6 +159,10 @@ struct GTY ((chain_next ("%h.next"))) loop { /* True if the loop can be parallel. */ bool can_be_parallel; + /* True if -Waggressive-loop-optimizations warned about this loop + already. */ + bool warned_aggressive_loop_optimizations; + /* An integer estimation of the number of iterations. Estimate_state describes what is the state of the estimation. */ enum loop_estimation estimate_state; 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/combine.c b/gcc/combine.c index acb74216589..acb4cb4c108 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -2845,13 +2845,13 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, /* See if the SETs in I1 or I2 need to be kept around in the merged instruction: whenever the value set there is still needed past I3. - For the SETs in I2, this is easy: we see if I2DEST dies or is set in I3. + For the SET in I2, this is easy: we see if I2DEST dies or is set in I3. - For the SET in I1, we have two cases: If I1 and I2 independently - feed into I3, the set in I1 needs to be kept around if I1DEST dies + For the SET in I1, we have two cases: if I1 and I2 independently feed + into I3, the set in I1 needs to be kept around unless I1DEST dies or is set in I3. Otherwise (if I1 feeds I2 which feeds I3), the set in I1 needs to be kept around unless I1DEST dies or is set in either - I2 or I3. The same consideration applies to I0. */ + I2 or I3. The same considerations apply to I0. */ added_sets_2 = !dead_or_set_p (i3, i2dest); @@ -2863,8 +2863,9 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, if (i0) added_sets_0 = !(dead_or_set_p (i3, i0dest) - || (i0_feeds_i2_n && dead_or_set_p (i2, i0dest)) - || (i0_feeds_i1_n && dead_or_set_p (i1, i0dest))); + || (i0_feeds_i1_n && dead_or_set_p (i1, i0dest)) + || ((i0_feeds_i2_n || (i0_feeds_i1_n && i1_feeds_i2_n)) + && dead_or_set_p (i2, i0dest))); else added_sets_0 = 0; @@ -4158,14 +4159,12 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, if (i3dest_killed) { + rtx new_note = alloc_reg_note (REG_DEAD, i3dest_killed, NULL_RTX); if (newi2pat && reg_set_p (i3dest_killed, newi2pat)) - distribute_notes (alloc_reg_note (REG_DEAD, i3dest_killed, - NULL_RTX), - NULL_RTX, i2, NULL_RTX, elim_i2, elim_i1, elim_i0); + distribute_notes (new_note, NULL_RTX, i2, NULL_RTX, elim_i2, + elim_i1, elim_i0); else - distribute_notes (alloc_reg_note (REG_DEAD, i3dest_killed, - NULL_RTX), - NULL_RTX, i3, newi2pat ? i2 : NULL_RTX, + distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX, elim_i2, elim_i1, elim_i0); } diff --git a/gcc/common.opt b/gcc/common.opt index 3c7b4153846..bdbd3b6cd9e 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -505,6 +505,10 @@ Waggregate-return Common Var(warn_aggregate_return) Warning Warn about returning structures, unions or arrays +Waggressive-loop-optimizations +Common Var(warn_aggressive_loop_optimizations) Init(1) Warning +Warn if a loop with constant number of iterations triggers undefined behavior + Warray-bounds Common Var(warn_array_bounds) Warning Warn if an array is accessed out of bounds diff --git a/gcc/config.gcc b/gcc/config.gcc index 64302a7bb39..1a0be50f033 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -536,6 +536,9 @@ x86_64-*-*) fi tm_file="vxworks-dummy.h ${tm_file}" ;; +arm*-*-* | mips*-*-* | sh*-*-* | sparc*-*-*) + tm_file="vxworks-dummy.h ${tm_file}" + ;; esac # On a.out targets, we need to use collect2. @@ -861,7 +864,7 @@ arm-wrs-vxworks) tmake_file="${tmake_file} arm/t-arm arm/t-vxworks" ;; arm*-*-netbsdelf*) - tm_file="dbxelf.h elfos.h netbsd.h netbsd-elf.h arm/elf.h arm/aout.h arm/arm.h arm/netbsd-elf.h" + tm_file="dbxelf.h elfos.h netbsd.h netbsd-elf.h arm/elf.h arm/aout.h ${tm_file} arm/netbsd-elf.h" extra_options="${extra_options} netbsd.opt netbsd-elf.opt" tmake_file="${tmake_file} arm/t-arm" ;; @@ -873,7 +876,7 @@ arm*-*-linux-*) # ARM GNU/Linux with ELF ;; esac tmake_file="${tmake_file} arm/t-arm arm/t-arm-elf arm/t-bpabi arm/t-linux-eabi" - tm_file="$tm_file arm/bpabi.h arm/linux-eabi.h arm/aout.h arm/arm.h" + tm_file="$tm_file arm/bpabi.h arm/linux-eabi.h arm/aout.h vxworks-dummy.h arm/arm.h" # Define multilib configuration for arm-linux-androideabi. case ${target} in *-androideabi) @@ -891,7 +894,7 @@ arm*-*-linux-*) # ARM GNU/Linux with ELF arm*-*-uclinux*eabi*) # ARM ucLinux tm_file="dbxelf.h elfos.h arm/unknown-elf.h arm/elf.h arm/linux-gas.h arm/uclinux-elf.h glibc-stdint.h" tmake_file="arm/t-arm arm/t-arm-elf arm/t-bpabi" - tm_file="$tm_file arm/bpabi.h arm/uclinux-eabi.h arm/aout.h arm/arm.h" + tm_file="$tm_file arm/bpabi.h arm/uclinux-eabi.h arm/aout.h vxworks-dummy.h arm/arm.h" # The BPABI long long divmod functions return a 128-bit value in # registers r0-r3. Correctly modeling that requires the use of # TImode. @@ -928,7 +931,7 @@ arm*-*-eabi* | arm*-*-symbianelf* | arm*-*-rtems*) tmake_file="${tmake_file} arm/t-symbian" ;; esac - tm_file="${tm_file} arm/aout.h arm/arm.h" + tm_file="${tm_file} arm/aout.h vxworks-dummy.h arm/arm.h" ;; avr-*-rtems*) tm_file="elfos.h avr/elf.h avr/avr-arch.h avr/avr.h dbxelf.h avr/rtems.h rtems.h newlib-stdint.h" diff --git a/gcc/config.in b/gcc/config.in index d80fb9f6e11..de8271bcfe2 100644 --- a/gcc/config.in +++ b/gcc/config.in @@ -327,6 +327,12 @@ #endif +/* Define if your assembler supports interunit movq mnemonic. */ +#ifndef USED_FOR_TARGET +#undef HAVE_AS_IX86_INTERUNIT_MOVQ +#endif + + /* Define if your assembler supports the .quad directive. */ #ifndef USED_FOR_TARGET #undef HAVE_AS_IX86_QUAD @@ -1034,6 +1040,12 @@ #endif +/* Define if your assembler supports the .set micromips directive */ +#ifndef USED_FOR_TARGET +#undef HAVE_GAS_MICROMIPS +#endif + + /* Define if your assembler supports .nsubspa comdat option. */ #ifndef USED_FOR_TARGET #undef HAVE_GAS_NSUBSPA_COMDAT @@ -1211,6 +1223,12 @@ #endif +/* Define 0/1 if your linker supports CIE v3 in .eh_frame. */ +#ifndef USED_FOR_TARGET +#undef HAVE_LD_EH_FRAME_CIEV3 +#endif + + /* Define if your linker supports .eh_frame_hdr. */ #undef HAVE_LD_EH_FRAME_HDR diff --git a/gcc/config/aarch64/aarch64-elf.h b/gcc/config/aarch64/aarch64-elf.h index db08031b178..3f3ae526a2a 100644 --- a/gcc/config/aarch64/aarch64-elf.h +++ b/gcc/config/aarch64/aarch64-elf.h @@ -106,7 +106,6 @@ #define ASM_COMMENT_START "//" -#define REGISTER_PREFIX "" #define LOCAL_LABEL_PREFIX "." #define USER_LABEL_PREFIX "" diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md index 0f0009505d8..92dcfc0c57b 100644 --- a/gcc/config/aarch64/aarch64-simd.md +++ b/gcc/config/aarch64/aarch64-simd.md @@ -44,6 +44,7 @@ ; simd_dup duplicate element. ; simd_dupgp duplicate general purpose register. ; simd_ext bitwise extract from pair. +; simd_fabd floating absolute difference and accumulate. ; simd_fadd floating point add/sub. ; simd_fcmp floating point compare. ; simd_fcvti floating point convert to integer. @@ -147,6 +148,7 @@ simd_dup,\ simd_dupgp,\ simd_ext,\ + simd_fabd,\ simd_fadd,\ simd_fcmp,\ simd_fcvti,\ @@ -520,6 +522,40 @@ (set_attr "simd_mode" "<MODE>")] ) +(define_insn "abd<mode>_3" + [(set (match_operand:VDQ_BHSI 0 "register_operand" "=w") + (abs:VDQ_BHSI (minus:VDQ_BHSI + (match_operand:VDQ_BHSI 1 "register_operand" "w") + (match_operand:VDQ_BHSI 2 "register_operand" "w"))))] + "TARGET_SIMD" + "sabd\t%0.<Vtype>, %1.<Vtype>, %2.<Vtype>" + [(set_attr "simd_type" "simd_abd") + (set_attr "simd_mode" "<MODE>")] +) + +(define_insn "aba<mode>_3" + [(set (match_operand:VDQ_BHSI 0 "register_operand" "=w") + (plus:VDQ_BHSI (abs:VDQ_BHSI (minus:VDQ_BHSI + (match_operand:VDQ_BHSI 1 "register_operand" "w") + (match_operand:VDQ_BHSI 2 "register_operand" "w"))) + (match_operand:VDQ_BHSI 3 "register_operand" "0")))] + "TARGET_SIMD" + "saba\t%0.<Vtype>, %1.<Vtype>, %2.<Vtype>" + [(set_attr "simd_type" "simd_abd") + (set_attr "simd_mode" "<MODE>")] +) + +(define_insn "fabd<mode>_3" + [(set (match_operand:VDQF 0 "register_operand" "=w") + (abs:VDQF (minus:VDQF + (match_operand:VDQF 1 "register_operand" "w") + (match_operand:VDQF 2 "register_operand" "w"))))] + "TARGET_SIMD" + "fabd\t%0.<Vtype>, %1.<Vtype>, %2.<Vtype>" + [(set_attr "simd_type" "simd_fabd") + (set_attr "simd_mode" "<MODE>")] +) + (define_insn "and<mode>3" [(set (match_operand:VDQ 0 "register_operand" "=w") (and:VDQ (match_operand:VDQ 1 "register_operand" "w") diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c index 8c8532c97cc..343586e28c8 100644 --- a/gcc/config/aarch64/aarch64.c +++ b/gcc/config/aarch64/aarch64.c @@ -3086,7 +3086,7 @@ aarch64_select_cc_mode (RTX_CODE code, rtx x, rtx y) if ((GET_MODE (x) == SImode || GET_MODE (x) == DImode) && y == const0_rtx && (code == EQ || code == NE || code == LT || code == GE) - && (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS)) + && (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS || GET_CODE (x) == AND)) return CC_NZmode; /* A compare with a shifted operand. Because of canonicalization, @@ -3348,7 +3348,7 @@ aarch64_print_operand (FILE *f, rtx x, char code) output_operand_lossage ("incompatible floating point / vector register operand for '%%%c'", code); return; } - asm_fprintf (f, "%s%c%d", REGISTER_PREFIX, code, REGNO (x) - V0_REGNUM); + asm_fprintf (f, "%c%d", code, REGNO (x) - V0_REGNUM); break; case 'S': @@ -3361,8 +3361,17 @@ aarch64_print_operand (FILE *f, rtx x, char code) output_operand_lossage ("incompatible floating point / vector register operand for '%%%c'", code); return; } - asm_fprintf (f, "%sv%d", REGISTER_PREFIX, - REGNO (x) - V0_REGNUM + (code - 'S')); + asm_fprintf (f, "v%d", REGNO (x) - V0_REGNUM + (code - 'S')); + break; + + case 'X': + /* Print integer constant in hex. */ + if (GET_CODE (x) != CONST_INT) + { + output_operand_lossage ("invalid operand for '%%%c'", code); + return; + } + asm_fprintf (f, "0x%x", UINTVAL (x)); break; case 'w': @@ -3372,20 +3381,19 @@ aarch64_print_operand (FILE *f, rtx x, char code) if (x == const0_rtx || (CONST_DOUBLE_P (x) && aarch64_float_const_zero_rtx_p (x))) { - asm_fprintf (f, "%s%czr", REGISTER_PREFIX, code); + asm_fprintf (f, "%czr", code); break; } if (REG_P (x) && GP_REGNUM_P (REGNO (x))) { - asm_fprintf (f, "%s%c%d", REGISTER_PREFIX, code, - REGNO (x) - R0_REGNUM); + asm_fprintf (f, "%c%d", code, REGNO (x) - R0_REGNUM); break; } if (REG_P (x) && REGNO (x) == SP_REGNUM) { - asm_fprintf (f, "%s%ssp", REGISTER_PREFIX, code == 'w' ? "w" : ""); + asm_fprintf (f, "%ssp", code == 'w' ? "w" : ""); break; } diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md index 73d86a7a184..c28f4a013dc 100644 --- a/gcc/config/aarch64/aarch64.md +++ b/gcc/config/aarch64/aarch64.md @@ -844,8 +844,8 @@ (match_operand:GPI 2 "const_int_operand" "n"))] "INTVAL (operands[1]) < GET_MODE_BITSIZE (<MODE>mode) && INTVAL (operands[1]) % 16 == 0 - && INTVAL (operands[2]) <= 0xffff" - "movk\\t%<w>0, %2, lsl %1" + && UINTVAL (operands[2]) <= 0xffff" + "movk\\t%<w>0, %X2, lsl %1" [(set_attr "v8type" "movk") (set_attr "mode" "<MODE>")] ) @@ -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") @@ -2547,8 +2575,8 @@ ) (define_insn "*and<mode>3nr_compare0" - [(set (reg:CC CC_REGNUM) - (compare:CC + [(set (reg:CC_NZ CC_REGNUM) + (compare:CC_NZ (and:GPI (match_operand:GPI 0 "register_operand" "%r,r") (match_operand:GPI 1 "aarch64_logical_operand" "r,<lconst>")) (const_int 0)))] @@ -2558,8 +2586,8 @@ (set_attr "mode" "<MODE>")]) (define_insn "*and_<SHIFT:optab><mode>3nr_compare0" - [(set (reg:CC CC_REGNUM) - (compare:CC + [(set (reg:CC_NZ CC_REGNUM) + (compare:CC_NZ (and:GPI (SHIFT:GPI (match_operand:GPI 0 "register_operand" "r") (match_operand:QI 1 "aarch64_shift_imm_<mode>" "n")) @@ -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/aarch64/t-aarch64-linux b/gcc/config/aarch64/t-aarch64-linux index 48b4c69f6b4..a7a0a883605 100644 --- a/gcc/config/aarch64/t-aarch64-linux +++ b/gcc/config/aarch64/t-aarch64-linux @@ -22,4 +22,4 @@ LIB1ASMSRC = aarch64/lib1funcs.asm LIB1ASMFUNCS = _aarch64_sync_cache_range AARCH_BE = $(if $(findstring TARGET_BIG_ENDIAN_DEFAULT=1, $(tm_defines)),_be) -MULTIARCH_DIRNAME = $(call if_multiarch,aarch64$(AARCH_BE)-linux-gnu) +MULTILIB_OSDIRNAMES = .=../lib64$(call if_multiarch,:aarch64$(AARCH_BE)-linux-gnu) 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-protos.h b/gcc/config/arm/arm-protos.h index ffa00c0f7b7..694aa2802ae 100644 --- a/gcc/config/arm/arm-protos.h +++ b/gcc/config/arm/arm-protos.h @@ -269,6 +269,8 @@ struct tune_params bool logical_op_non_short_circuit[2]; /* Vectorizer costs. */ const struct cpu_vec_costs* vec_costs; + /* Prefer Neon for 64-bit bitops. */ + bool prefer_neon_for_64bits; }; extern const struct tune_params *current_tune; diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c index 36b86dd760c..567b75ece9c 100644 --- a/gcc/config/arm/arm.c +++ b/gcc/config/arm/arm.c @@ -840,6 +840,10 @@ int arm_arch_thumb2; int arm_arch_arm_hwdiv; int arm_arch_thumb_hwdiv; +/* Nonzero if we should use Neon to handle 64-bits operations rather + than core registers. */ +int prefer_neon_for_64bits = 0; + /* In case of a PRE_INC, POST_INC, PRE_DEC, POST_DEC memory reference, we must report the mode of the memory reference from TARGET_PRINT_OPERAND to TARGET_PRINT_OPERAND_ADDRESS. */ @@ -937,6 +941,7 @@ const struct tune_params arm_slowmul_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; const struct tune_params arm_fastmul_tune = @@ -951,6 +956,7 @@ const struct tune_params arm_fastmul_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; /* StrongARM has early execution of branches, so a sequence that is worth @@ -968,6 +974,7 @@ const struct tune_params arm_strongarm_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; const struct tune_params arm_xscale_tune = @@ -982,6 +989,7 @@ const struct tune_params arm_xscale_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; const struct tune_params arm_9e_tune = @@ -996,6 +1004,7 @@ const struct tune_params arm_9e_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; const struct tune_params arm_v6t2_tune = @@ -1010,6 +1019,7 @@ const struct tune_params arm_v6t2_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; /* Generic Cortex tuning. Use more specific tunings if appropriate. */ @@ -1025,6 +1035,7 @@ const struct tune_params arm_cortex_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; const struct tune_params arm_cortex_a15_tune = @@ -1039,6 +1050,7 @@ const struct tune_params arm_cortex_a15_tune = true, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; /* Branches can be dual-issued on Cortex-A5, so conditional execution is @@ -1056,6 +1068,7 @@ const struct tune_params arm_cortex_a5_tune = false, /* Prefer LDRD/STRD. */ {false, false}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; const struct tune_params arm_cortex_a9_tune = @@ -1070,6 +1083,7 @@ const struct tune_params arm_cortex_a9_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; /* The arm_v6m_tune is duplicated from arm_cortex_tune, rather than @@ -1086,6 +1100,7 @@ const struct tune_params arm_v6m_tune = false, /* Prefer LDRD/STRD. */ {false, false}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; const struct tune_params arm_fa726te_tune = @@ -1100,6 +1115,7 @@ const struct tune_params arm_fa726te_tune = false, /* Prefer LDRD/STRD. */ {true, true}, /* Prefer non short circuit. */ &arm_default_vec_cost, /* Vectorizer costs. */ + false /* Prefer Neon for 64-bits bitops. */ }; @@ -2130,6 +2146,12 @@ arm_option_override (void) global_options.x_param_values, global_options_set.x_param_values); + /* Use Neon to perform 64-bits operations rather than core + registers. */ + prefer_neon_for_64bits = current_tune->prefer_neon_for_64bits; + if (use_neon_for_64bits == 1) + prefer_neon_for_64bits = true; + /* Use the alternative scheduling-pressure algorithm by default. */ maybe_set_param_value (PARAM_SCHED_PRESSURE_ALGORITHM, 2, global_options.x_param_values, diff --git a/gcc/config/arm/arm.h b/gcc/config/arm/arm.h index 6d336e89ee9..04bff13368e 100644 --- a/gcc/config/arm/arm.h +++ b/gcc/config/arm/arm.h @@ -354,6 +354,9 @@ extern void (*arm_lang_output_object_attributes_hook)(void); #define TARGET_IDIV ((TARGET_ARM && arm_arch_arm_hwdiv) \ || (TARGET_THUMB2 && arm_arch_thumb_hwdiv)) +/* Should NEON be used for 64-bits bitops. */ +#define TARGET_PREFER_NEON_64BITS (prefer_neon_for_64bits) + /* True iff the full BPABI is being used. If TARGET_BPABI is true, then TARGET_AAPCS_BASED must be true -- but the converse does not hold. TARGET_BPABI implies the use of the BPABI runtime library, @@ -539,6 +542,10 @@ extern int arm_arch_arm_hwdiv; /* Nonzero if chip supports integer division instruction in Thumb mode. */ extern int arm_arch_thumb_hwdiv; +/* Nonzero if we should use Neon to handle 64-bits operations rather + than core registers. */ +extern int prefer_neon_for_64bits; + #ifndef TARGET_DEFAULT #define TARGET_DEFAULT (MASK_APCS_FRAME) #endif @@ -1166,7 +1173,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/arm/arm.md b/gcc/config/arm/arm.md index f3c59f37c85..d48bc8c0123 100644 --- a/gcc/config/arm/arm.md +++ b/gcc/config/arm/arm.md @@ -94,7 +94,7 @@ ; for ARM or Thumb-2 with arm_arch6, and nov6 for ARM without ; arm_arch6. This attribute is used to compute attribute "enabled", ; use type "any" to enable an alternative in all cases. -(define_attr "arch" "any,a,t,32,t1,t2,v6,nov6,onlya8,neon_onlya8,nota8,neon_nota8,iwmmxt,iwmmxt2" +(define_attr "arch" "any,a,t,32,t1,t2,v6,nov6,neon_for_64bits,avoid_neon_for_64bits,iwmmxt,iwmmxt2" (const_string "any")) (define_attr "arch_enabled" "no,yes" @@ -129,22 +129,14 @@ (match_test "TARGET_32BIT && !arm_arch6")) (const_string "yes") - (and (eq_attr "arch" "onlya8") - (eq_attr "tune" "cortexa8")) + (and (eq_attr "arch" "avoid_neon_for_64bits") + (match_test "TARGET_NEON") + (not (match_test "TARGET_PREFER_NEON_64BITS"))) (const_string "yes") - (and (eq_attr "arch" "neon_onlya8") - (eq_attr "tune" "cortexa8") - (match_test "TARGET_NEON")) - (const_string "yes") - - (and (eq_attr "arch" "nota8") - (not (eq_attr "tune" "cortexa8"))) - (const_string "yes") - - (and (eq_attr "arch" "neon_nota8") - (not (eq_attr "tune" "cortexa8")) - (match_test "TARGET_NEON")) + (and (eq_attr "arch" "neon_for_64bits") + (match_test "TARGET_NEON") + (match_test "TARGET_PREFER_NEON_64BITS")) (const_string "yes") (and (eq_attr "arch" "iwmmxt2") @@ -4330,7 +4322,7 @@ [(set_attr "length" "*,8,8,*") (set_attr "predicable" "no,yes,yes,no") (set_attr "neon_type" "neon_int_1,*,*,neon_int_1") - (set_attr "arch" "neon_nota8,*,*,neon_onlya8")] + (set_attr "arch" "neon_for_64bits,*,*,avoid_neon_for_64bits")] ) (define_expand "one_cmplsi2" @@ -4498,7 +4490,7 @@ "TARGET_32BIT <qhs_zextenddi_cond>" "#" [(set_attr "length" "8,4,8,8") - (set_attr "arch" "neon_nota8,*,*,neon_onlya8") + (set_attr "arch" "neon_for_64bits,*,*,avoid_neon_for_64bits") (set_attr "ce_count" "2") (set_attr "predicable" "yes")] ) @@ -4513,7 +4505,7 @@ (set_attr "ce_count" "2") (set_attr "shift" "1") (set_attr "predicable" "yes") - (set_attr "arch" "neon_nota8,*,a,t,neon_onlya8")] + (set_attr "arch" "neon_for_64bits,*,a,t,avoid_neon_for_64bits")] ) ;; Splits for all extensions to DImode diff --git a/gcc/config/arm/arm.opt b/gcc/config/arm/arm.opt index e778407ab4c..afb42421c06 100644 --- a/gcc/config/arm/arm.opt +++ b/gcc/config/arm/arm.opt @@ -247,3 +247,7 @@ that may trigger Cortex-M3 errata. munaligned-access Target Report Var(unaligned_access) Init(2) Enable unaligned word and halfword accesses to packed data. + +mneon-for-64bits +Target Report RejectNegative Var(use_neon_for_64bits) Init(0) +Use Neon to perform 64-bits operations rather than core registers. diff --git a/gcc/config/arm/iterators.md b/gcc/config/arm/iterators.md index 252f18b40a8..b3ad42b376f 100644 --- a/gcc/config/arm/iterators.md +++ b/gcc/config/arm/iterators.md @@ -314,6 +314,12 @@ (V2SF "V2SI") (V4SF "V4SI") (DI "DI") (V2DI "V2DI")]) +(define_mode_attr v_cmp_result [(V8QI "v8qi") (V16QI "v16qi") + (V4HI "v4hi") (V8HI "v8hi") + (V2SI "v2si") (V4SI "v4si") + (DI "di") (V2DI "v2di") + (V2SF "v2si") (V4SF "v4si")]) + ;; Get element type from double-width mode, for operations where we ;; don't care about signedness. (define_mode_attr V_if_elem [(V8QI "i8") (V16QI "i8") diff --git a/gcc/config/arm/neon.md b/gcc/config/arm/neon.md index 79b3f667c17..d7c2cb36949 100644 --- a/gcc/config/arm/neon.md +++ b/gcc/config/arm/neon.md @@ -487,7 +487,7 @@ [(set_attr "neon_type" "neon_int_1,*,*,neon_int_1,*,*,*") (set_attr "conds" "*,clob,clob,*,clob,clob,clob") (set_attr "length" "*,8,8,*,8,8,8") - (set_attr "arch" "nota8,*,*,onlya8,*,*,*")] + (set_attr "arch" "neon_for_64bits,*,*,avoid_neon_for_64bits,*,*,*")] ) (define_insn "*sub<mode>3_neon" @@ -524,7 +524,7 @@ [(set_attr "neon_type" "neon_int_2,*,*,*,neon_int_2") (set_attr "conds" "*,clob,clob,clob,*") (set_attr "length" "*,8,8,8,*") - (set_attr "arch" "nota8,*,*,*,onlya8")] + (set_attr "arch" "neon_for_64bits,*,*,*,avoid_neon_for_64bits")] ) (define_insn "*mul<mode>3_neon" @@ -699,7 +699,7 @@ } [(set_attr "neon_type" "neon_int_1,neon_int_1,*,*,neon_int_1,neon_int_1") (set_attr "length" "*,*,8,8,*,*") - (set_attr "arch" "nota8,nota8,*,*,onlya8,onlya8")] + (set_attr "arch" "neon_for_64bits,neon_for_64bits,*,*,avoid_neon_for_64bits,avoid_neon_for_64bits")] ) ;; The concrete forms of the Neon immediate-logic instructions are vbic and @@ -744,7 +744,7 @@ } [(set_attr "neon_type" "neon_int_1,neon_int_1,*,*,neon_int_1,neon_int_1") (set_attr "length" "*,*,8,8,*,*") - (set_attr "arch" "nota8,nota8,*,*,onlya8,onlya8")] + (set_attr "arch" "neon_for_64bits,neon_for_64bits,*,*,avoid_neon_for_64bits,avoid_neon_for_64bits")] ) (define_insn "orn<mode>3_neon" @@ -840,7 +840,7 @@ veor\t%P0, %P1, %P2" [(set_attr "neon_type" "neon_int_1,*,*,neon_int_1") (set_attr "length" "*,8,8,*") - (set_attr "arch" "nota8,*,*,onlya8")] + (set_attr "arch" "neon_for_64bits,*,*,avoid_neon_for_64bits")] ) (define_insn "one_cmpl<mode>2" @@ -1162,7 +1162,7 @@ } DONE; }" - [(set_attr "arch" "nota8,nota8,*,*,onlya8,onlya8") + [(set_attr "arch" "neon_for_64bits,neon_for_64bits,*,*,avoid_neon_for_64bits,avoid_neon_for_64bits") (set_attr "opt" "*,*,speed,speed,*,*")] ) @@ -1263,7 +1263,7 @@ DONE; }" - [(set_attr "arch" "nota8,nota8,*,*,onlya8,onlya8") + [(set_attr "arch" "neon_for_64bits,neon_for_64bits,*,*,avoid_neon_for_64bits,avoid_neon_for_64bits") (set_attr "opt" "*,*,speed,speed,*,*")] ) @@ -1721,80 +1721,144 @@ (define_expand "vcond<mode><mode>" [(set (match_operand:VDQW 0 "s_register_operand" "") (if_then_else:VDQW - (match_operator 3 "arm_comparison_operator" + (match_operator 3 "comparison_operator" [(match_operand:VDQW 4 "s_register_operand" "") (match_operand:VDQW 5 "nonmemory_operand" "")]) (match_operand:VDQW 1 "s_register_operand" "") (match_operand:VDQW 2 "s_register_operand" "")))] "TARGET_NEON && (!<Is_float_mode> || flag_unsafe_math_optimizations)" { - rtx mask; - int inverse = 0, immediate_zero = 0; - /* See the description of "magic" bits in the 'T' case of - arm_print_operand. */ HOST_WIDE_INT magic_word = (<MODE>mode == V2SFmode || <MODE>mode == V4SFmode) ? 3 : 1; rtx magic_rtx = GEN_INT (magic_word); - - mask = gen_reg_rtx (<V_cmp_result>mode); - - if (operands[5] == CONST0_RTX (<MODE>mode)) - immediate_zero = 1; - else if (!REG_P (operands[5])) - operands[5] = force_reg (<MODE>mode, operands[5]); - + int inverse = 0; + int swap_bsl_operands = 0; + rtx mask = gen_reg_rtx (<V_cmp_result>mode); + rtx tmp = gen_reg_rtx (<V_cmp_result>mode); + + rtx (*base_comparison) (rtx, rtx, rtx, rtx); + rtx (*complimentary_comparison) (rtx, rtx, rtx, rtx); + switch (GET_CODE (operands[3])) { case GE: - emit_insn (gen_neon_vcge<mode> (mask, operands[4], operands[5], - magic_rtx)); + case LE: + case EQ: + if (!REG_P (operands[5]) + && (operands[5] != CONST0_RTX (<MODE>mode))) + operands[5] = force_reg (<MODE>mode, operands[5]); break; - + default: + if (!REG_P (operands[5])) + operands[5] = force_reg (<MODE>mode, operands[5]); + } + + switch (GET_CODE (operands[3])) + { + case LT: + case UNLT: + inverse = 1; + /* Fall through. */ + case GE: + case UNGE: + case ORDERED: + case UNORDERED: + base_comparison = gen_neon_vcge<mode>; + complimentary_comparison = gen_neon_vcgt<mode>; + break; + case LE: + case UNLE: + inverse = 1; + /* Fall through. */ case GT: - emit_insn (gen_neon_vcgt<mode> (mask, operands[4], operands[5], - magic_rtx)); + case UNGT: + base_comparison = gen_neon_vcgt<mode>; + complimentary_comparison = gen_neon_vcge<mode>; break; - case EQ: - emit_insn (gen_neon_vceq<mode> (mask, operands[4], operands[5], - magic_rtx)); + case NE: + case UNEQ: + base_comparison = gen_neon_vceq<mode>; + complimentary_comparison = gen_neon_vceq<mode>; break; - + default: + gcc_unreachable (); + } + + switch (GET_CODE (operands[3])) + { + case LT: case LE: - if (immediate_zero) - emit_insn (gen_neon_vcle<mode> (mask, operands[4], operands[5], - magic_rtx)); + case GT: + case GE: + case EQ: + /* The easy case. Here we emit one of vcge, vcgt or vceq. + As a LT b <=> b GE a && a LE b <=> b GT a. Our transformations are: + a GE b -> a GE b + a GT b -> a GT b + a LE b -> b GE a + a LT b -> b GT a + a EQ b -> a EQ b */ + + if (!inverse) + emit_insn (base_comparison (mask, operands[4], operands[5], magic_rtx)); else - emit_insn (gen_neon_vcge<mode> (mask, operands[5], operands[4], - magic_rtx)); + emit_insn (complimentary_comparison (mask, operands[5], operands[4], magic_rtx)); break; - - case LT: - if (immediate_zero) - emit_insn (gen_neon_vclt<mode> (mask, operands[4], operands[5], - magic_rtx)); + case UNLT: + case UNLE: + case UNGT: + case UNGE: + case NE: + /* Vector compare returns false for lanes which are unordered, so if we use + the inverse of the comparison we actually want to emit, then + swap the operands to BSL, we will end up with the correct result. + Note that a NE NaN and NaN NE b are true for all a, b. + + Our transformations are: + a GE b -> !(b GT a) + a GT b -> !(b GE a) + a LE b -> !(a GT b) + a LT b -> !(a GE b) + a NE b -> !(a EQ b) */ + + if (inverse) + emit_insn (base_comparison (mask, operands[4], operands[5], magic_rtx)); else - emit_insn (gen_neon_vcgt<mode> (mask, operands[5], operands[4], - magic_rtx)); + emit_insn (complimentary_comparison (mask, operands[5], operands[4], magic_rtx)); + + swap_bsl_operands = 1; break; - - case NE: - emit_insn (gen_neon_vceq<mode> (mask, operands[4], operands[5], - magic_rtx)); - inverse = 1; + case UNEQ: + /* We check (a > b || b > a). combining these comparisons give us + true iff !(a != b && a ORDERED b), swapping the operands to BSL + will then give us (a == b || a UNORDERED b) as intended. */ + + emit_insn (gen_neon_vcgt<mode> (mask, operands[4], operands[5], magic_rtx)); + emit_insn (gen_neon_vcgt<mode> (tmp, operands[5], operands[4], magic_rtx)); + emit_insn (gen_ior<v_cmp_result>3 (mask, mask, tmp)); + swap_bsl_operands = 1; + break; + case UNORDERED: + /* Operands are ORDERED iff (a > b || b >= a). + Swapping the operands to BSL will give the UNORDERED case. */ + swap_bsl_operands = 1; + /* Fall through. */ + case ORDERED: + emit_insn (gen_neon_vcgt<mode> (tmp, operands[4], operands[5], magic_rtx)); + emit_insn (gen_neon_vcge<mode> (mask, operands[5], operands[4], magic_rtx)); + emit_insn (gen_ior<v_cmp_result>3 (mask, mask, tmp)); break; - default: gcc_unreachable (); } - - if (inverse) + + if (swap_bsl_operands) emit_insn (gen_neon_vbsl<mode> (operands[0], mask, operands[2], operands[1])); else emit_insn (gen_neon_vbsl<mode> (operands[0], mask, operands[1], operands[2])); - DONE; }) diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c index a35f47e83d6..3f2b54a169c 100644 --- a/gcc/config/avr/avr.c +++ b/gcc/config/avr/avr.c @@ -7629,9 +7629,9 @@ _reg_unused_after (rtx insn, rtx reg) rtx this_insn = XVECEXP (PATTERN (insn), 0, i); rtx set = single_set (this_insn); - if (GET_CODE (this_insn) == CALL_INSN) + if (CALL_P (this_insn)) code = CALL_INSN; - else if (GET_CODE (this_insn) == JUMP_INSN) + else if (JUMP_P (this_insn)) { if (INSN_ANNULLED_BRANCH_P (this_insn)) return 0; @@ -10765,6 +10765,66 @@ avr_addr_space_subset_p (addr_space_t subset ATTRIBUTE_UNUSED, } +/* Implement `TARGET_CONVERT_TO_TYPE'. */ + +static tree +avr_convert_to_type (tree type, tree expr) +{ + /* Print a diagnose for pointer conversion that changes the address + space of the pointer target to a non-enclosing address space, + provided -Waddr-space-convert is on. + + FIXME: Filter out cases where the target object is known to + be located in the right memory, like in + + (const __flash*) PSTR ("text") + + Also try to distinguish between explicit casts requested by + the user and implicit casts like + + void f (const __flash char*); + + void g (const char *p) + { + f ((const __flash*) p); + } + + under the assumption that an explicit casts means that the user + knows what he is doing, e.g. interface with PSTR or old style + code with progmem and pgm_read_xxx. + */ + + if (avr_warn_addr_space_convert + && expr != error_mark_node + && POINTER_TYPE_P (type) + && POINTER_TYPE_P (TREE_TYPE (expr))) + { + addr_space_t as_old = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (expr))); + addr_space_t as_new = TYPE_ADDR_SPACE (TREE_TYPE (type)); + + if (avr_log.progmem) + avr_edump ("%?: type = %t\nexpr = %t\n\n", type, expr); + + if (as_new != ADDR_SPACE_MEMX + && as_new != as_old) + { + location_t loc = EXPR_LOCATION (expr); + const char *name_old = avr_addrspace[as_old].name; + const char *name_new = avr_addrspace[as_new].name; + + warning (OPT_Waddr_space_convert, + "conversion from address space %qs to address space %qs", + ADDR_SPACE_GENERIC_P (as_old) ? "generic" : name_old, + ADDR_SPACE_GENERIC_P (as_new) ? "generic" : name_new); + + return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, expr); + } + } + + return NULL_TREE; +} + + /* Worker function for movmemhi expander. XOP[0] Destination as MEM:BLK XOP[1] Source " " @@ -12149,6 +12209,9 @@ avr_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED, tree *arg, #undef TARGET_FIXED_POINT_SUPPORTED_P #define TARGET_FIXED_POINT_SUPPORTED_P hook_bool_void_true +#undef TARGET_CONVERT_TO_TYPE +#define TARGET_CONVERT_TO_TYPE avr_convert_to_type + #undef TARGET_ADDR_SPACE_SUBSET_P #define TARGET_ADDR_SPACE_SUBSET_P avr_addr_space_subset_p diff --git a/gcc/config/avr/avr.opt b/gcc/config/avr/avr.opt index 134a1d4d0d7..6b2e755eeb2 100644 --- a/gcc/config/avr/avr.opt +++ b/gcc/config/avr/avr.opt @@ -74,3 +74,7 @@ When accessing RAM, use X as imposed by the hardware, i.e. just use pre-decremen msp8 Target Report RejectNegative Var(avr_sp8) Init(0) The device has no SPH special function register. This option will be overridden by the compiler driver with the correct setting if presence/absence of SPH can be deduced from -mmcu=MCU. + +Waddr-space-convert +Warning C Report Var(avr_warn_addr_space_convert) Init(0) +Warn if the address space of an address is change. diff --git a/gcc/config/bfin/bfin.c b/gcc/config/bfin/bfin.c index 97c1d21682d..a2d22c1c26f 100644 --- a/gcc/config/bfin/bfin.c +++ b/gcc/config/bfin/bfin.c @@ -3887,8 +3887,7 @@ gen_one_bundle (rtx slot[3]) rtx t = NEXT_INSN (slot[0]); while (t != slot[1]) { - if (GET_CODE (t) != NOTE - || NOTE_KIND (t) != NOTE_INSN_DELETED) + if (! NOTE_P (t) || NOTE_KIND (t) != NOTE_INSN_DELETED) return false; t = NEXT_INSN (t); } @@ -3898,8 +3897,7 @@ gen_one_bundle (rtx slot[3]) rtx t = NEXT_INSN (slot[1]); while (t != slot[2]) { - if (GET_CODE (t) != NOTE - || NOTE_KIND (t) != NOTE_INSN_DELETED) + if (! NOTE_P (t) || NOTE_KIND (t) != NOTE_INSN_DELETED) return false; t = NEXT_INSN (t); } diff --git a/gcc/config/c6x/c6x.c b/gcc/config/c6x/c6x.c index e0db8b12a27..f66ad55978e 100644 --- a/gcc/config/c6x/c6x.c +++ b/gcc/config/c6x/c6x.c @@ -4848,7 +4848,7 @@ reorg_split_calls (rtx *call_labels) { unsigned int reservation_mask = 0; rtx insn = get_insns (); - gcc_assert (GET_CODE (insn) == NOTE); + gcc_assert (NOTE_P (insn)); insn = next_real_insn (insn); while (insn) { diff --git a/gcc/config/epiphany/epiphany.c b/gcc/config/epiphany/epiphany.c index 782dc7b3e75..5520a633c1f 100644 --- a/gcc/config/epiphany/epiphany.c +++ b/gcc/config/epiphany/epiphany.c @@ -2386,7 +2386,7 @@ epiphany_mode_after (int entity, int last_mode, rtx insn) calls. */ if (entity == EPIPHANY_MSW_ENTITY_AND || entity == EPIPHANY_MSW_ENTITY_OR) { - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) return 0; return last_mode; } diff --git a/gcc/config/frv/frv.c b/gcc/config/frv/frv.c index 8fe4655950c..fd5349f218e 100644 --- a/gcc/config/frv/frv.c +++ b/gcc/config/frv/frv.c @@ -1408,7 +1408,7 @@ frv_function_contains_far_jump (void) { rtx insn = get_insns (); while (insn != NULL - && !(GET_CODE (insn) == JUMP_INSN + && !(JUMP_P (insn) /* Ignore tablejump patterns. */ && GET_CODE (PATTERN (insn)) != ADDR_VEC && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC @@ -1446,7 +1446,7 @@ frv_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED) simply emit a different assembly directive because bralr and jmpl execute in different units. */ for (insn = get_insns(); insn != NULL; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == JUMP_INSN) + if (JUMP_P (insn)) { rtx pattern = PATTERN (insn); if (GET_CODE (pattern) == PARALLEL @@ -2649,7 +2649,7 @@ frv_print_operand_jump_hint (rtx insn) HOST_WIDE_INT prob = -1; enum { UNKNOWN, BACKWARD, FORWARD } jump_type = UNKNOWN; - gcc_assert (GET_CODE (insn) == JUMP_INSN); + gcc_assert (JUMP_P (insn)); /* Assume any non-conditional jump is likely. */ if (! any_condjump_p (insn)) @@ -7387,7 +7387,7 @@ frv_pack_insn_p (rtx insn) - There's no point putting a call in its own packet unless we have to. */ if (frv_packet.num_insns > 0 - && GET_CODE (insn) == INSN + && NONJUMP_INSN_P (insn) && GET_MODE (insn) == TImode && GET_CODE (PATTERN (insn)) != COND_EXEC) return false; @@ -7430,7 +7430,7 @@ frv_insert_nop_in_packet (rtx insn) packet_group = &frv_packet.groups[frv_unit_groups[frv_insn_unit (insn)]]; last = frv_packet.insns[frv_packet.num_insns - 1]; - if (GET_CODE (last) != INSN) + if (! NONJUMP_INSN_P (last)) { insn = emit_insn_before (PATTERN (insn), last); frv_packet.insns[frv_packet.num_insns - 1] = insn; @@ -7492,7 +7492,7 @@ frv_for_each_packet (void (*handle_packet) (void)) default: /* Calls mustn't be packed on a TOMCAT. */ - if (GET_CODE (insn) == CALL_INSN && frv_cpu_type == FRV_CPU_TOMCAT) + if (CALL_P (insn) && frv_cpu_type == FRV_CPU_TOMCAT) frv_finish_packet (handle_packet); /* Since the last instruction in a packet determines the EH @@ -7913,7 +7913,7 @@ frv_optimize_membar_local (basic_block bb, struct frv_io *next_io, CLEAR_HARD_REG_SET (used_regs); for (insn = BB_END (bb); insn != BB_HEAD (bb); insn = PREV_INSN (insn)) - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) { /* We can't predict what a call will do to volatile memory. */ memset (next_io, 0, sizeof (struct frv_io)); 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/cygwin.h b/gcc/config/i386/cygwin.h index de0a3fd3b3c..7f92ada9f7c 100644 --- a/gcc/config/i386/cygwin.h +++ b/gcc/config/i386/cygwin.h @@ -48,11 +48,7 @@ along with GCC; see the file COPYING3. If not see %{static|static-libgcc:-lgcc -lgcc_eh} \ %{!static: \ %{!static-libgcc: \ - %{!shared: \ - %{!shared-libgcc:-lgcc -lgcc_eh} \ - %{shared-libgcc:-lgcc_s -lgcc} \ - } \ - %{shared:-lgcc_s -lgcc} \ + -lgcc_s -lgcc \ } \ } " #else diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index 24d1012d5ce..475da37cb9b 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"))] @@ -1722,12 +1758,12 @@ (match_operand:OI 1 "vector_move_operand" "C ,xm,x"))] "TARGET_AVX && !(MEM_P (operands[0]) && MEM_P (operands[1]))" { - switch (which_alternative) + switch (get_attr_type (insn)) { - case 0: + case TYPE_SSELOG1: return standard_sse_constant_opcode (insn, operands[1]); - case 1: - case 2: + + case TYPE_SSEMOV: if (misaligned_operand (operands[0], OImode) || misaligned_operand (operands[1], OImode)) { @@ -1743,6 +1779,7 @@ else return "vmovdqa\t{%1, %0|%0, %1}"; } + default: gcc_unreachable (); } @@ -1758,20 +1795,21 @@ ] (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) + switch (get_attr_type (insn)) { - case 0: - case 1: + case TYPE_MULTI: return "#"; - case 2: + + case TYPE_SSELOG1: return standard_sse_constant_opcode (insn, operands[1]); - case 3: - case 4: + + case TYPE_SSEMOV: /* 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) @@ -1789,16 +1827,22 @@ else return "%vmovdqa\t{%1, %0|%0, %1}"; } + default: gcc_unreachable (); } } - [(set_attr "type" "*,*,sselog1,ssemov,ssemov") - (set_attr "prefix" "*,*,maybe_vex,maybe_vex,maybe_vex") + [(set_attr "isa" "x64,x64,*,*,*") + (set_attr "type" "multi,multi,sselog1,ssemov,ssemov") + (set (attr "prefix") + (if_then_else (eq_attr "type" "sselog1,ssemov") + (const_string "maybe_vex") + (const_string "orig"))) (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,120 +1862,98 @@ [(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,*y,?*y,?m,?r ,?*Ym,*x,*x,*x,m ,?r ,?*Yi,?*Ym,?*Yi") (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 ,*y,*Ym,r ,C ,*x,m ,*x,*Yi,r ,*Yi ,*Ym"))] + "!(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: +#ifndef HAVE_AS_IX86_INTERUNIT_MOVQ /* Handle broken assemblers that require movd instead of movq. */ if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1])) return "movd\t{%1, %0|%0, %1}"; - else - return "movq\t{%1, %0|%0, %1}"; +#endif + 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_SSEMOV: + switch (get_attr_mode (insn)) + { + case MODE_DI: +#ifndef HAVE_AS_IX86_INTERUNIT_MOVQ + /* 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}"; +#endif + return "%vmovq\t{%1, %0|%0, %1}"; + case MODE_TI: + return "%vmovdqa\t{%1, %0|%0, %1}"; + + case MODE_V2SF: + gcc_assert (!TARGET_AVX); + return "movlps\t{%1, %0|%0, %1}"; + case MODE_V4SF: + return "%vmovaps\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}"; - default: + case TYPE_IMOV: 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}"; else return "mov{q}\t{%1, %0|%0, %1}"; + + default: + gcc_unreachable (); } } - [(set (attr "type") - (cond [(eq_attr "alternative" "4") + [(set (attr "isa") + (cond [(eq_attr "alternative" "0,1") + (const_string "nox64") + (eq_attr "alternative" "2,3,4,5,10,11,16,17") + (const_string "x64") + ] + (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,161 +1961,45 @@ (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,16,17") (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,13") + (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") + (and (eq_attr "alternative" "14,15") + (not (match_test "TARGET_SSE2"))) + (const_string "V2SF") ] - (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")) - ] - (const_string "DI")))]) + (const_string "DI")))]) (define_split [(set (match_operand:DI 0 "nonimmediate_operand") @@ -2106,9 +2012,9 @@ (define_insn "*movsi_internal" [(set (match_operand:SI 0 "nonimmediate_operand" - "=r,m ,*y,*y,?rm,?*y,*x,*x,?r ,m ,?*Yi,*x") + "=r,m ,*y,*y,?rm,?*y,*x,*x,*x,m ,?r ,?*Yi") (match_operand:SI 1 "general_operand" - "g ,re,C ,*y,*y ,rm ,C ,*x,*Yi,*x,r ,m"))] + "g ,re,C ,*y,*y ,rm ,C ,*x,m ,*x,*Yi,r"))] "!(MEM_P (operands[0]) && MEM_P (operands[1]))" { switch (get_attr_type (insn)) @@ -2119,14 +2025,18 @@ case TYPE_SSEMOV: switch (get_attr_mode (insn)) { + case MODE_SI: + return "%vmovd\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_SI: - return "%vmovd\t{%1, %0|%0, %1}"; + case MODE_SF: - return "%vmovss\t{%1, %0|%0, %1}"; + gcc_assert (!TARGET_AVX); + return "movss\t{%1, %0|%0, %1}"; + default: gcc_unreachable (); } @@ -2135,19 +2045,29 @@ return "pxor\t%0, %0"; case TYPE_MMXMOV: - if (get_attr_mode (insn) == MODE_DI) - return "movq\t{%1, %0|%0, %1}"; - return "movd\t{%1, %0|%0, %1}"; + switch (get_attr_mode (insn)) + { + case MODE_DI: + return "movq\t{%1, %0|%0, %1}"; + case MODE_SI: + return "movd\t{%1, %0|%0, %1}"; + + default: + gcc_unreachable (); + } case TYPE_LEA: return "lea{l}\t{%E1, %0|%0, %E1}"; - default: + case TYPE_IMOV: gcc_assert (!flag_pic || LEGITIMATE_PIC_OPERAND_P (operands[1])); if (ix86_use_lea_for_mov (insn, operands)) return "lea{l}\t{%E1, %0|%0, %E1}"; else return "mov{l}\t{%1, %0|%0, %1}"; + + default: + gcc_unreachable (); } } [(set (attr "type") @@ -2164,9 +2084,9 @@ ] (const_string "imov"))) (set (attr "prefix") - (if_then_else (eq_attr "alternative" "0,1,2,3,4,5") - (const_string "orig") - (const_string "maybe_vex"))) + (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" "SI")) (const_string "1") @@ -2175,16 +2095,17 @@ (cond [(eq_attr "alternative" "2,3") (const_string "DI") (eq_attr "alternative" "6,7") - (cond [(match_test "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL") + (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") - (ior (not (match_test "TARGET_SSE2")) - (match_test "optimize_function_for_size_p (cfun)")) + (match_test "optimize_function_for_size_p (cfun)") (const_string "V4SF") ] (const_string "TI")) - (and (eq_attr "alternative" "8,9,10,11") + + (and (eq_attr "alternative" "8,9") (not (match_test "TARGET_SSE2"))) (const_string "SF") ] @@ -2582,16 +2503,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 +2525,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 +2550,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 +2586,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 +2630,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 +2638,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 @@ -2760,12 +2652,12 @@ || (!TARGET_MEMORY_MISMATCH_STALL && memory_operand (operands[0], TFmode)))" { - switch (which_alternative) + switch (get_attr_type (insn)) { - case 0: + case TYPE_SSELOG1: return standard_sse_constant_opcode (insn, operands[1]); - case 1: - case 2: + + case TYPE_SSEMOV: /* Handle misaligned load/store since we don't have movmisaligntf pattern. */ if (misaligned_operand (operands[0], TFmode) @@ -2784,16 +2676,19 @@ return "%vmovdqa\t{%1, %0|%0, %1}"; } - case 3: - case 4: + case TYPE_MULTI: return "#"; default: gcc_unreachable (); } } - [(set_attr "type" "sselog1,ssemov,ssemov,*,*") - (set_attr "prefix" "maybe_vex,maybe_vex,maybe_vex,*,*") + [(set_attr "isa" "*,*,*,x64,x64") + (set_attr "type" "sselog1,ssemov,ssemov,multi,multi") + (set (attr "prefix") + (if_then_else (eq_attr "type" "sselog1,ssemov") + (const_string "maybe_vex") + (const_string "orig"))) (set (attr "mode") (cond [(eq_attr "alternative" "3,4") (const_string "DI") @@ -2810,101 +2705,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 @@ -2914,177 +2721,37 @@ || (!TARGET_MEMORY_MISMATCH_STALL && memory_operand (operands[0], XFmode)))" { - switch (which_alternative) + switch (get_attr_type (insn)) { - case 0: - case 1: + case TYPE_FMOV: + if (which_alternative == 2) + return standard_80387_constant_opcode (operands[1]); return output_387_reg_move (insn, operands); - case 2: - return standard_80387_constant_opcode (operands[1]); - - case 3: - case 4: + case TYPE_MULTI: 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 ,r ,Yi") (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,Yi,r"))] + "!(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,49 +2761,58 @@ || (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) + switch (get_attr_type (insn)) { - case 0: - case 1: + case TYPE_FMOV: + if (which_alternative == 2) + return standard_80387_constant_opcode (operands[1]); return output_387_reg_move (insn, operands); - case 2: - return standard_80387_constant_opcode (operands[1]); - - case 3: - case 4: + case TYPE_MULTI: return "#"; - case 5: - case 9: + case TYPE_IMOV: + if (get_attr_mode (insn) == MODE_SI) + return "mov{l}\t{%1, %k0|%k0, %1}"; + else if (which_alternative == 8) + return "movabs{q}\t{%1, %0|%0, %1}"; + else + return "mov{q}\t{%1, %0|%0, %1}"; + + case TYPE_SSELOG1: return standard_sse_constant_opcode (insn, operands[1]); - case 6: - case 7: - case 8: - case 10: - case 11: - case 12: + case TYPE_SSEMOV: 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_V4SF: + return "%vmovaps\t{%1, %0|%0, %1}"; + case MODE_V2DF: + return "%vmovapd\t{%1, %0|%0, %1}"; + case MODE_V2SF: - return "%vmovlps\t{%1, %d0|%d0, %1}"; + gcc_assert (!TARGET_AVX); + return "movlps\t{%1, %0|%0, %1}"; + case MODE_V1DF: + gcc_assert (!TARGET_AVX); + return "movlpd\t{%1, %0|%0, %1}"; + + case MODE_DI: +#ifndef HAVE_AS_IX86_INTERUNIT_MOVQ + /* 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}"; +#endif + return "%vmovq\t{%1, %0|%0, %1}"; + default: gcc_unreachable (); } @@ -3146,42 +2822,54 @@ } } [(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") - (const_string "orig") - (const_string "maybe_vex"))) + (if_then_else (eq_attr "type" "sselog1,ssemov") + (const_string "maybe_vex") + (const_string "orig"))) (set (attr "prefix_data16") - (if_then_else (eq_attr "mode" "V1DF") + (if_then_else + (ior (and (eq_attr "type" "ssemov") (eq_attr "mode" "DI")) + (eq_attr "mode" "V1DF")) (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") + (eq_attr "alternative" "5,6,8,17,18") + (const_string "DI") - /* 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")) - - /* xorps is one byte shorter for !TARGET_AVX. */ - (eq_attr "alternative" "5,9") - (cond [(match_test "TARGET_AVX") + /* xorps is one byte shorter for non-AVX targets. */ + (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") @@ -3191,12 +2879,13 @@ (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. + whole SSE registers use movapd to break dependency + 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") + /* movaps is one byte shorter for non-AVX targets. */ + (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") @@ -3204,25 +2893,33 @@ (const_string "DF") (match_test "optimize_function_for_size_p (cfun)") (const_string "V4SF") - ] - (const_string "DF")) + ] + (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" "7,11") - (if_then_else - (match_test "TARGET_SSE_SPLIT_REGS") - (const_string "V1DF") - (const_string "DF")) + (eq_attr "alternative" "11,15") + (cond [(not (match_test "TARGET_SSE2")) + (const_string "V2SF") + (match_test "TARGET_AVX") + (const_string "DF") + (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")))]) (define_insn "*movsf_internal" [(set (match_operand:SF 0 "nonimmediate_operand" - "=Yf*f,m ,Yf*f,?r ,?m,x,x,x,m,!*y,!m,!*y,?Yi,?r,!*Ym,!r") + "=Yf*f,m ,Yf*f,?r ,?m,x,x,x,m,?r,?Yi,!*y,!*y,!m,!r ,!*Ym") (match_operand:SF 1 "general_operand" - "Yf*fm,Yf*f,G ,rmF,rF,C,x,m,x,m ,*y,*y ,r ,Yi,r ,*Ym"))] + "Yf*fm,Yf*f,G ,rmF,rF,C,x,m,x,Yi,r ,*y ,m ,*y,*Ym,r"))] "!(MEM_P (operands[0]) && MEM_P (operands[1])) && (!can_create_pseudo_p () || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE) @@ -3234,44 +2931,48 @@ && standard_sse_constant_p (operands[1])))) || memory_operand (operands[0], SFmode))" { - switch (which_alternative) + switch (get_attr_type (insn)) { - case 0: - case 1: + case TYPE_FMOV: + if (which_alternative == 2) + return standard_80387_constant_opcode (operands[1]); return output_387_reg_move (insn, operands); - case 2: - return standard_80387_constant_opcode (operands[1]); - - case 3: - case 4: + case TYPE_IMOV: return "mov{l}\t{%1, %0|%0, %1}"; - case 5: + case TYPE_SSELOG1: return standard_sse_constant_opcode (insn, operands[1]); - case 6: - if (get_attr_mode (insn) == MODE_V4SF) - return "%vmovaps\t{%1, %0|%0, %1}"; - if (TARGET_AVX) - return "vmovss\t{%1, %0, %0|%0, %0, %1}"; + case TYPE_SSEMOV: + switch (get_attr_mode (insn)) + { + case MODE_SF: + if (TARGET_AVX && REG_P (operands[0]) && REG_P (operands[1])) + return "vmovss\t{%1, %0, %0|%0, %0, %1}"; + return "%vmovss\t{%1, %0|%0, %1}"; - case 7: - case 8: - return "%vmovss\t{%1, %0|%0, %1}"; + case MODE_V4SF: + return "%vmovaps\t{%1, %0|%0, %1}"; - case 9: - case 10: - case 14: - case 15: - return "movd\t{%1, %0|%0, %1}"; + case MODE_SI: + return "%vmovd\t{%1, %0|%0, %1}"; - case 11: - return "movq\t{%1, %0|%0, %1}"; + default: + gcc_unreachable (); + } - case 12: - case 13: - return "%vmovd\t{%1, %0|%0, %1}"; + case TYPE_MMXMOV: + switch (get_attr_mode (insn)) + { + case MODE_DI: + return "movq\t{%1, %0|%0, %1}"; + case MODE_SI: + return "movd\t{%1, %0|%0, %1}"; + + default: + gcc_unreachable (); + } default: gcc_unreachable (); @@ -3281,27 +2982,34 @@ (cond [(eq_attr "alternative" "0,1,2") (const_string "fmov") (eq_attr "alternative" "3,4") - (const_string "multi") + (const_string "imov") (eq_attr "alternative" "5") (const_string "sselog1") - (eq_attr "alternative" "9,10,11,14,15") + (eq_attr "alternative" "11,12,13,14,15") (const_string "mmxmov") ] (const_string "ssemov"))) (set (attr "prefix") - (if_then_else (eq_attr "alternative" "5,6,7,8,12,13") + (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" "SI")) + (const_string "1") + (const_string "*"))) (set (attr "mode") - (cond [(eq_attr "alternative" "3,4,9,10") + (cond [(eq_attr "alternative" "3,4,9,10,14,15") (const_string "SI") + (eq_attr "alternative" "11") + (const_string "DI") (eq_attr "alternative" "5") - (cond [(match_test "TARGET_AVX") - (const_string "V4SF") - (ior (not (match_test "TARGET_SSE2")) - (match_test "optimize_function_for_size_p (cfun)")) + (cond [(not (match_test "TARGET_SSE2")) (const_string "V4SF") - (match_test "TARGET_SSE_LOAD0_BY_PXOR") + (match_test "TARGET_AVX") + (const_string "V4SF") + (match_test "optimize_function_for_size_p (cfun)") + (const_string "V4SF") + (match_test "TARGET_SSE_LOAD0_BY_PXOR") (const_string "TI") ] (const_string "V4SF")) @@ -3316,15 +3024,12 @@ of instructions to load just part of the register. It is better to maintain the whole registers in single format to avoid problems on using packed logical operations. */ - (eq_attr "alternative" "6") - (if_then_else - (ior (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY") - (match_test "TARGET_SSE_SPLIT_REGS")) - (const_string "V4SF") - (const_string "SF")) - (eq_attr "alternative" "11") - (const_string "DI")] - (const_string "SF")))]) + (and (eq_attr "alternative" "6") + (ior (match_test "TARGET_SSE_PARTIAL_REG_DEPENDENCY") + (match_test "TARGET_SSE_SPLIT_REGS"))) + (const_string "V4SF") + ] + (const_string "SF")))]) (define_split [(set (match_operand 0 "any_fp_register_operand") diff --git a/gcc/config/i386/mmx.md b/gcc/config/i386/mmx.md index 232ecfac73c..fb75d49570a 100644 --- a/gcc/config/i386/mmx.md +++ b/gcc/config/i386/mmx.md @@ -68,260 +68,145 @@ ;; This is essential for maintaining stable calling conventions. (define_expand "mov<mode>" - [(set (match_operand:MMXMODEI8 0 "nonimmediate_operand") - (match_operand:MMXMODEI8 1 "nonimmediate_operand"))] + [(set (match_operand:MMXMODE 0 "nonimmediate_operand") + (match_operand:MMXMODE 1 "nonimmediate_operand"))] "TARGET_MMX" { ix86_expand_vector_move (<MODE>mode, operands); DONE; }) -;; movd instead of movq is required to handle broken assemblers. -(define_insn "*mov<mode>_internal_rex64" - [(set (match_operand:MMXMODEI8 0 "nonimmediate_operand" - "=rm,r,!?y,!y,!?y,m ,!y ,*x,x,x ,m,r ,Yi") - (match_operand:MMXMODEI8 1 "vector_move_operand" - "Cr ,m,C ,!y,m ,!?y,*x,!y ,C,xm,x,Yi,r"))] - "TARGET_64BIT && TARGET_MMX - && !(MEM_P (operands[0]) && MEM_P (operands[1]))" - "@ - mov{q}\t{%1, %0|%0, %1} - mov{q}\t{%1, %0|%0, %1} - pxor\t%0, %0 - movq\t{%1, %0|%0, %1} - movq\t{%1, %0|%0, %1} - movq\t{%1, %0|%0, %1} - movdq2q\t{%1, %0|%0, %1} - movq2dq\t{%1, %0|%0, %1} - %vpxor\t%0, %d0 - %vmovq\t{%1, %0|%0, %1} - %vmovq\t{%1, %0|%0, %1} - %vmovd\t{%1, %0|%0, %1} - %vmovd\t{%1, %0|%0, %1}" - [(set (attr "type") - (cond [(eq_attr "alternative" "0,1") - (const_string "imov") - (eq_attr "alternative" "2") - (const_string "mmx") - (eq_attr "alternative" "3,4,5") - (const_string "mmxmov") - (eq_attr "alternative" "6,7") - (const_string "ssecvt") - (eq_attr "alternative" "8") - (const_string "sselog1") - ] - (const_string "ssemov"))) - (set (attr "unit") - (if_then_else (eq_attr "alternative" "6,7") - (const_string "mmx") - (const_string "*"))) - (set (attr "prefix_rep") - (if_then_else (eq_attr "alternative" "6,7,9") - (const_string "1") - (const_string "*"))) - (set (attr "prefix_data16") - (if_then_else (eq_attr "alternative" "10,11,12") - (const_string "1") - (const_string "*"))) - (set (attr "prefix_rex") - (if_then_else (eq_attr "alternative" "9,10") - (symbol_ref "x86_extended_reg_mentioned_p (insn)") - (const_string "*"))) - (set (attr "prefix") - (if_then_else (eq_attr "alternative" "8,9,10,11,12") - (const_string "maybe_vex") - (const_string "orig"))) - (set_attr "mode" "DI")]) - (define_insn "*mov<mode>_internal" - [(set (match_operand:MMXMODEI8 0 "nonimmediate_operand" - "=!?y,!y,!?y,m ,!y,*x,*x,*x ,m ,*x,*x,*x,m ,r ,m") - (match_operand:MMXMODEI8 1 "vector_move_operand" - "C ,!y,m ,!?y,*x,!y,C ,*xm,*x,C ,*x,m ,*x,irm,r"))] - "!TARGET_64BIT && TARGET_MMX + [(set (match_operand:MMXMODE 0 "nonimmediate_operand" + "=r ,o ,r,r ,m ,?!y,!y,?!y,m ,r ,?!Ym,x,x,x,m,*x,*x,*x,m ,r ,Yi,!Ym,*Yi") + (match_operand:MMXMODE 1 "vector_move_operand" + "rCo,rC,C,rm,rC,C ,!y,m ,?!y,?!Ym,r ,C,x,m,x,C ,*x,m ,*x,Yi,r ,*Yi,!Ym"))] + "TARGET_MMX && !(MEM_P (operands[0]) && MEM_P (operands[1]))" - "@ - pxor\t%0, %0 - movq\t{%1, %0|%0, %1} - movq\t{%1, %0|%0, %1} - movq\t{%1, %0|%0, %1} - movdq2q\t{%1, %0|%0, %1} - movq2dq\t{%1, %0|%0, %1} - %vpxor\t%0, %d0 - %vmovq\t{%1, %0|%0, %1} - %vmovq\t{%1, %0|%0, %1} - xorps\t%0, %0 - movaps\t{%1, %0|%0, %1} - movlps\t{%1, %0|%0, %1} - movlps\t{%1, %0|%0, %1} - # - #" +{ + switch (get_attr_type (insn)) + { + case TYPE_MULTI: + return "#"; + + case TYPE_IMOV: + if (get_attr_mode (insn) == MODE_SI) + return "mov{l}\t{%1, %k0|%k0, %1}"; + else + return "mov{q}\t{%1, %0|%0, %1}"; + + case TYPE_MMX: + return "pxor\t%0, %0"; + + case TYPE_MMXMOV: +#ifndef HAVE_AS_IX86_INTERUNIT_MOVQ + /* Handle broken assemblers that require movd instead of movq. */ + if (GENERAL_REG_P (operands[0]) || GENERAL_REG_P (operands[1])) + return "movd\t{%1, %0|%0, %1}"; +#endif + return "movq\t{%1, %0|%0, %1}"; + + 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_SSELOG1: + return standard_sse_constant_opcode (insn, operands[1]); + + case TYPE_SSEMOV: + switch (get_attr_mode (insn)) + { + case MODE_DI: +#ifndef HAVE_AS_IX86_INTERUNIT_MOVQ + /* 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}"; +#endif + return "%vmovq\t{%1, %0|%0, %1}"; + case MODE_TI: + return "%vmovdqa\t{%1, %0|%0, %1}"; + + case MODE_V2SF: + if (TARGET_AVX && REG_P (operands[0])) + return "vmovlps\t{%1, %0, %0|%0, %0, %1}"; + return "%vmovlps\t{%1, %0|%0, %1}"; + case MODE_V4SF: + return "%vmovaps\t{%1, %0|%0, %1}"; + + default: + gcc_unreachable (); + } + + default: + gcc_unreachable (); + } +} [(set (attr "isa") - (cond [(eq_attr "alternative" "4,5,6,7,8") - (const_string "sse2") - (eq_attr "alternative" "9,10,11,12") - (const_string "noavx") + (cond [(eq_attr "alternative" "0,1") + (const_string "nox64") + (eq_attr "alternative" "2,3,4,9,10,11,12,13,14,19,20") + (const_string "x64") ] - (const_string "*"))) + (const_string "*"))) (set (attr "type") - (cond [(eq_attr "alternative" "0") - (const_string "mmx") - (eq_attr "alternative" "1,2,3") - (const_string "mmxmov") - (eq_attr "alternative" "4,5") - (const_string "ssecvt") - (eq_attr "alternative" "6,9") - (const_string "sselog1") - (eq_attr "alternative" "13,14") - (const_string "multi") - ] - (const_string "ssemov"))) - (set (attr "unit") - (if_then_else (eq_attr "alternative" "4,5") - (const_string "mmx") - (const_string "*"))) - (set (attr "prefix_rep") - (if_then_else - (ior (eq_attr "alternative" "4,5") - (and (eq_attr "alternative" "7") - (not (match_test "TARGET_AVX")))) - (const_string "1") - (const_string "*"))) - (set (attr "prefix_data16") - (if_then_else - (and (eq_attr "alternative" "8") - (not (match_test "TARGET_AVX"))) - (const_string "1") - (const_string "*"))) - (set (attr "prefix") - (if_then_else (eq_attr "alternative" "6,7,8") - (const_string "maybe_vex") - (const_string "orig"))) - (set_attr "mode" "DI,DI,DI,DI,DI,DI,TI,DI,DI,V4SF,V4SF,V2SF,V2SF,DI,DI")]) - -(define_expand "movv2sf" - [(set (match_operand:V2SF 0 "nonimmediate_operand") - (match_operand:V2SF 1 "nonimmediate_operand"))] - "TARGET_MMX" -{ - ix86_expand_vector_move (V2SFmode, operands); - DONE; -}) - -;; movd instead of movq is required to handle broken assemblers. -(define_insn "*movv2sf_internal_rex64" - [(set (match_operand:V2SF 0 "nonimmediate_operand" - "=rm,r,!?y,!y,!?y,m ,!y,*x,x,x,x,m,r ,Yi") - (match_operand:V2SF 1 "vector_move_operand" - "Cr ,m,C ,!y,m ,!?y,*x,!y,C,x,m,x,Yi,r"))] - "TARGET_64BIT && TARGET_MMX - && !(MEM_P (operands[0]) && MEM_P (operands[1]))" - "@ - mov{q}\t{%1, %0|%0, %1} - mov{q}\t{%1, %0|%0, %1} - pxor\t%0, %0 - movq\t{%1, %0|%0, %1} - movq\t{%1, %0|%0, %1} - movq\t{%1, %0|%0, %1} - movdq2q\t{%1, %0|%0, %1} - movq2dq\t{%1, %0|%0, %1} - %vxorps\t%0, %d0 - %vmovaps\t{%1, %0|%0, %1} - %vmovlps\t{%1, %d0|%d0, %1} - %vmovlps\t{%1, %0|%0, %1} - %vmovd\t{%1, %0|%0, %1} - %vmovd\t{%1, %0|%0, %1}" - [(set (attr "type") (cond [(eq_attr "alternative" "0,1") + (const_string "multi") + (eq_attr "alternative" "2,3,4") (const_string "imov") - (eq_attr "alternative" "2") + (eq_attr "alternative" "5") (const_string "mmx") - (eq_attr "alternative" "3,4,5") + (eq_attr "alternative" "6,7,8,9,10") (const_string "mmxmov") - (eq_attr "alternative" "6,7") - (const_string "ssecvt") - (eq_attr "alternative" "9") + (eq_attr "alternative" "11,15") (const_string "sselog1") + (eq_attr "alternative" "21,22") + (const_string "ssecvt") ] (const_string "ssemov"))) - (set (attr "unit") - (if_then_else (eq_attr "alternative" "6,7") - (const_string "mmx") - (const_string "*"))) - (set (attr "prefix_rep") - (if_then_else (eq_attr "alternative" "6,7") + (set (attr "prefix_rex") + (if_then_else (eq_attr "alternative" "9,10,19,20") (const_string "1") (const_string "*"))) - (set (attr "length_vex") - (if_then_else - (and (eq_attr "alternative" "12,13") - (match_test "TARGET_AVX")) - (const_string "4") - (const_string "*"))) (set (attr "prefix") - (if_then_else (eq_attr "alternative" "8,9,10,11,12,13") + (if_then_else (eq_attr "type" "sselog1,ssemov") (const_string "maybe_vex") (const_string "orig"))) - (set_attr "mode" "DI,DI,DI,DI,DI,DI,DI,DI,V4SF,V4SF,V2SF,V2SF,DI,DI")]) - -(define_insn "*movv2sf_internal" - [(set (match_operand:V2SF 0 "nonimmediate_operand" - "=!?y,!y,!?y,m ,!y,*x,*x,*x,*x,m ,r ,m") - (match_operand:V2SF 1 "vector_move_operand" - "C ,!y,m ,!?y,*x,!y,C ,*x,m ,*x,irm,r"))] - "!TARGET_64BIT && TARGET_MMX - && !(MEM_P (operands[0]) && MEM_P (operands[1]))" - "@ - pxor\t%0, %0 - movq\t{%1, %0|%0, %1} - movq\t{%1, %0|%0, %1} - movq\t{%1, %0|%0, %1} - movdq2q\t{%1, %0|%0, %1} - movq2dq\t{%1, %0|%0, %1} - %vxorps\t%0, %d0 - %vmovaps\t{%1, %0|%0, %1} - %vmovlps\t{%1, %d0|%d0, %1} - %vmovlps\t{%1, %0|%0, %1} - # - #" - [(set (attr "isa") - (if_then_else (eq_attr "alternative" "4,5") - (const_string "sse2") - (const_string "*"))) - (set (attr "type") - (cond [(eq_attr "alternative" "0") - (const_string "mmx") - (eq_attr "alternative" "1,2,3") - (const_string "mmxmov") - (eq_attr "alternative" "4,5") - (const_string "ssecvt") - (eq_attr "alternative" "6") - (const_string "sselog1") - (eq_attr "alternative" "10,11") - (const_string "multi") - ] - (const_string "ssemov"))) - (set (attr "unit") - (if_then_else (eq_attr "alternative" "4,5") - (const_string "mmx") - (const_string "*"))) - (set (attr "prefix_rep") - (if_then_else (eq_attr "alternative" "4,5") + (set (attr "prefix_data16") + (if_then_else + (and (eq_attr "type" "ssemov") (eq_attr "mode" "DI")) (const_string "1") (const_string "*"))) - (set (attr "prefix") - (if_then_else (eq_attr "alternative" "6,7,8,9") - (const_string "maybe_vex") - (const_string "orig"))) - (set_attr "mode" "DI,DI,DI,DI,DI,DI,V4SF,V4SF,V2SF,V2SF,DI,DI")]) + (set (attr "mode") + (cond [(eq_attr "alternative" "2") + (const_string "SI") + (eq_attr "alternative" "11,12,15,16") + (cond [(match_test "<MODE>mode == V2SFmode") + (const_string "V4SF") + (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")) + + (and (eq_attr "alternative" "13,14,17,18") + (ior (match_test "<MODE>mode == V2SFmode") + (not (match_test "TARGET_SSE2")))) + (const_string "V2SF") + ] + (const_string "DI")))]) -;; %%% This multiword shite has got to go. (define_split [(set (match_operand:MMXMODE 0 "nonimmediate_operand") (match_operand:MMXMODE 1 "general_operand"))] "!TARGET_64BIT && reload_completed - && !(MMX_REG_P (operands[0]) || SSE_REG_P (operands[0]) - || MMX_REG_P (operands[1]) || SSE_REG_P (operands[1]))" + && !(MMX_REG_P (operands[0]) || SSE_REG_P (operands[0])) + && !(MMX_REG_P (operands[1]) || SSE_REG_P (operands[1]))" [(const_int 0)] "ix86_split_long_move (operands); DONE;") diff --git a/gcc/config/i386/predicates.md b/gcc/config/i386/predicates.md index f5657b964a0..d098dc5423d 100644 --- a/gcc/config/i386/predicates.md +++ b/gcc/config/i386/predicates.md @@ -436,6 +436,9 @@ if (SYMBOL_REF_TLS_MODEL (op)) return false; + /* Dll-imported symbols are always external. */ + if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op)) + return false; if (SYMBOL_REF_LOCAL_P (op)) return true; diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c index 9ad5d1504a7..2f5220c91dc 100644 --- a/gcc/config/ia64/ia64.c +++ b/gcc/config/ia64/ia64.c @@ -5468,7 +5468,7 @@ ia64_print_operand (FILE * file, rtx x, int code) else which = ".sptk"; } - else if (GET_CODE (current_output_insn) == CALL_INSN) + else if (CALL_P (current_output_insn)) which = ".sptk"; else which = ".dptk"; @@ -6809,8 +6809,7 @@ group_barrier_needed (rtx insn) memset (rws_insn, 0, sizeof (rws_insn)); /* Don't bundle a call following another call. */ - if ((pat = prev_active_insn (insn)) - && GET_CODE (pat) == CALL_INSN) + if ((pat = prev_active_insn (insn)) && CALL_P (pat)) { need_barrier = 1; break; @@ -6824,8 +6823,7 @@ group_barrier_needed (rtx insn) flags.is_branch = 1; /* Don't bundle a jump following a call. */ - if ((pat = prev_active_insn (insn)) - && GET_CODE (pat) == CALL_INSN) + if ((pat = prev_active_insn (insn)) && CALL_P (pat)) { need_barrier = 1; break; @@ -6927,20 +6925,20 @@ emit_insn_group_barriers (FILE *dump) for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) { - if (GET_CODE (insn) == CODE_LABEL) + if (LABEL_P (insn)) { if (insns_since_last_label) last_label = insn; insns_since_last_label = 0; } - else if (GET_CODE (insn) == NOTE + else if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_BASIC_BLOCK) { if (insns_since_last_label) last_label = insn; insns_since_last_label = 0; } - else if (GET_CODE (insn) == INSN + else if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == UNSPEC_VOLATILE && XINT (PATTERN (insn), 1) == UNSPECV_INSN_GROUP_BARRIER) { @@ -6981,13 +6979,13 @@ emit_all_insn_group_barriers (FILE *dump ATTRIBUTE_UNUSED) for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) { - if (GET_CODE (insn) == BARRIER) + if (BARRIER_P (insn)) { rtx last = prev_active_insn (insn); if (! last) continue; - if (GET_CODE (last) == JUMP_INSN + if (JUMP_P (last) && GET_CODE (PATTERN (last)) == ADDR_DIFF_VEC) last = prev_active_insn (last); if (recog_memoized (last) != CODE_FOR_insn_group_barrier) @@ -7485,7 +7483,7 @@ ia64_variable_issue (FILE *dump ATTRIBUTE_UNUSED, int needed = group_barrier_needed (insn); gcc_assert (!needed); - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) init_insn_group_barriers (); stops_p [INSN_UID (insn)] = stop_before_p; stop_before_p = 0; @@ -7574,7 +7572,7 @@ ia64_dfa_new_cycle (FILE *dump, int verbose, rtx insn, int last_clock, && last_scheduled_insn && scheduled_good_insn (last_scheduled_insn)))) || (last_scheduled_insn - && (GET_CODE (last_scheduled_insn) == CALL_INSN + && (CALL_P (last_scheduled_insn) || unknown_for_bundling_p (last_scheduled_insn)))) { init_insn_group_barriers (); @@ -7592,7 +7590,7 @@ ia64_dfa_new_cycle (FILE *dump, int verbose, rtx insn, int last_clock, state_transition (curr_state, dfa_stop_insn); if (TARGET_EARLY_STOP_BITS) *sort_p = (last_scheduled_insn == NULL_RTX - || GET_CODE (last_scheduled_insn) != CALL_INSN); + || ! CALL_P (last_scheduled_insn)); else *sort_p = 0; return 1; @@ -8933,9 +8931,9 @@ ia64_add_bundle_selector_before (int template0, rtx insn) { do insn = next_active_insn (insn); - while (GET_CODE (insn) == INSN + while (NONJUMP_INSN_P (insn) && get_attr_empty (insn) == EMPTY_YES); - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); else if (note) { @@ -9369,13 +9367,13 @@ final_emit_insn_group_barriers (FILE *dump ATTRIBUTE_UNUSED) insn != current_sched_info->next_tail; insn = NEXT_INSN (insn)) { - if (GET_CODE (insn) == BARRIER) + if (BARRIER_P (insn)) { rtx last = prev_active_insn (insn); if (! last) continue; - if (GET_CODE (last) == JUMP_INSN + if (JUMP_P (last) && GET_CODE (PATTERN (last)) == ADDR_DIFF_VEC) last = prev_active_insn (last); if (recog_memoized (last) != CODE_FOR_insn_group_barrier) @@ -9442,8 +9440,7 @@ final_emit_insn_group_barriers (FILE *dump ATTRIBUTE_UNUSED) else if (recog_memoized (insn) >= 0 && important_for_bundling_p (insn)) seen_good_insn = 1; - need_barrier_p = (GET_CODE (insn) == CALL_INSN - || unknown_for_bundling_p (insn)); + need_barrier_p = (CALL_P (insn) || unknown_for_bundling_p (insn)); } } } @@ -9587,7 +9584,7 @@ emit_predicate_relation_info (void) rtx head = BB_HEAD (bb); /* We only need such notes at code labels. */ - if (GET_CODE (head) != CODE_LABEL) + if (! LABEL_P (head)) continue; if (NOTE_INSN_BASIC_BLOCK_P (NEXT_INSN (head))) head = NEXT_INSN (head); @@ -9615,7 +9612,7 @@ emit_predicate_relation_info (void) while (1) { - if (GET_CODE (insn) == CALL_INSN + if (CALL_P (insn) && GET_CODE (PATTERN (insn)) == COND_EXEC && find_reg_note (insn, REG_NORETURN, NULL_RTX)) { @@ -9763,7 +9760,7 @@ ia64_reorg (void) if (insn) { /* Skip over insns that expand to nothing. */ - while (GET_CODE (insn) == INSN + while (NONJUMP_INSN_P (insn) && get_attr_empty (insn) == EMPTY_YES) { if (GET_CODE (PATTERN (insn)) == UNSPEC_VOLATILE @@ -9771,7 +9768,7 @@ ia64_reorg (void) saw_stop = 1; insn = prev_active_insn (insn); } - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) { if (! saw_stop) emit_insn (gen_insn_group_barrier (GEN_INT (3))); @@ -10181,7 +10178,7 @@ ia64_asm_unwind_emit (FILE *asm_out_file, rtx insn) } } - if (GET_CODE (insn) == NOTE || ! RTX_FRAME_RELATED_P (insn)) + if (NOTE_P (insn) || ! RTX_FRAME_RELATED_P (insn)) return; /* Look for the ALLOC insn. */ diff --git a/gcc/config/iq2000/iq2000.c b/gcc/config/iq2000/iq2000.c index c2933986bda..7e19366ae93 100644 --- a/gcc/config/iq2000/iq2000.c +++ b/gcc/config/iq2000/iq2000.c @@ -381,8 +381,7 @@ iq2000_fill_delay_slot (const char *ret, enum delay_type type, rtx operands[], /* Make sure that we don't put nop's after labels. */ next_insn = NEXT_INSN (cur_insn); while (next_insn != 0 - && (GET_CODE (next_insn) == NOTE - || GET_CODE (next_insn) == CODE_LABEL)) + && (NOTE_P (next_insn) || LABEL_P (next_insn))) next_insn = NEXT_INSN (next_insn); dslots_load_total += num_nops; @@ -391,7 +390,7 @@ iq2000_fill_delay_slot (const char *ret, enum delay_type type, rtx operands[], || operands == 0 || cur_insn == 0 || next_insn == 0 - || GET_CODE (next_insn) == CODE_LABEL + || LABEL_P (next_insn) || (set_reg = operands[0]) == 0) { dslots_number_nops = 0; @@ -1533,8 +1532,8 @@ final_prescan_insn (rtx insn, rtx opvec[] ATTRIBUTE_UNUSED, iq2000_load_reg4 = 0; } - if ( (GET_CODE (insn) == JUMP_INSN - || GET_CODE (insn) == CALL_INSN + if ( (JUMP_P (insn) + || CALL_P (insn) || (GET_CODE (PATTERN (insn)) == RETURN)) && NEXT_INSN (PREV_INSN (insn)) == insn) { @@ -1544,7 +1543,7 @@ final_prescan_insn (rtx insn, rtx opvec[] ATTRIBUTE_UNUSED, } if (TARGET_STATS - && (GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == CALL_INSN)) + && (JUMP_P (insn) || CALL_P (insn))) dslots_jump_total ++; } @@ -2285,8 +2284,8 @@ iq2000_adjust_insn_length (rtx insn, int length) /* A unconditional jump has an unfilled delay slot if it is not part of a sequence. A conditional jump normally has a delay slot. */ if (simplejump_p (insn) - || ( (GET_CODE (insn) == JUMP_INSN - || GET_CODE (insn) == CALL_INSN))) + || ( (JUMP_P (insn) + || CALL_P (insn)))) length += 4; return length; diff --git a/gcc/config/mcore/mcore.c b/gcc/config/mcore/mcore.c index e730362e0cc..6550b6905f0 100644 --- a/gcc/config/mcore/mcore.c +++ b/gcc/config/mcore/mcore.c @@ -914,10 +914,10 @@ mcore_is_dead (rtx first, rtx reg) to assume that it is live. */ for (insn = NEXT_INSN (first); insn; insn = NEXT_INSN (insn)) { - if (GET_CODE (insn) == JUMP_INSN) + if (JUMP_P (insn)) return 0; /* We lose track, assume it is alive. */ - else if (GET_CODE(insn) == CALL_INSN) + else if (CALL_P (insn)) { /* Call's might use it for target or register parms. */ if (reg_referenced_p (reg, PATTERN (insn)) @@ -926,7 +926,7 @@ mcore_is_dead (rtx first, rtx reg) else if (dead_or_set_p (insn, reg)) return 1; } - else if (GET_CODE (insn) == INSN) + else if (NONJUMP_INSN_P (insn)) { if (reg_referenced_p (reg, PATTERN (insn))) return 0; @@ -2254,7 +2254,7 @@ is_cond_candidate (rtx insn) changed into a conditional. Only bother with SImode items. If we wanted to be a little more aggressive, we could also do other modes such as DImode with reg-reg move or load 0. */ - if (GET_CODE (insn) == INSN) + if (NONJUMP_INSN_P (insn)) { rtx pat = PATTERN (insn); rtx src, dst; @@ -2305,9 +2305,9 @@ is_cond_candidate (rtx insn) */ } - else if (GET_CODE (insn) == JUMP_INSN && - GET_CODE (PATTERN (insn)) == SET && - GET_CODE (XEXP (PATTERN (insn), 1)) == LABEL_REF) + else if (JUMP_P (insn) + && GET_CODE (PATTERN (insn)) == SET + && GET_CODE (XEXP (PATTERN (insn), 1)) == LABEL_REF) return COND_BRANCH_INSN; return COND_NO; @@ -2328,7 +2328,7 @@ emit_new_cond_insn (rtx insn, int cond) pat = PATTERN (insn); - if (GET_CODE (insn) == INSN) + if (NONJUMP_INSN_P (insn)) { dst = SET_DEST (pat); src = SET_SRC (pat); @@ -2449,9 +2449,9 @@ conditionalize_block (rtx first) /* Check that the first insn is a candidate conditional jump. This is the one that we'll eliminate. If not, advance to the next insn to try. */ - if (GET_CODE (first) != JUMP_INSN || - GET_CODE (PATTERN (first)) != SET || - GET_CODE (XEXP (PATTERN (first), 1)) != IF_THEN_ELSE) + if (! JUMP_P (first) + || GET_CODE (PATTERN (first)) != SET + || GET_CODE (XEXP (PATTERN (first), 1)) != IF_THEN_ELSE) return NEXT_INSN (first); /* Extract some information we need. */ diff --git a/gcc/config/mep/mep.c b/gcc/config/mep/mep.c index c190d316045..60054f9ae57 100644 --- a/gcc/config/mep/mep.c +++ b/gcc/config/mep/mep.c @@ -4882,7 +4882,7 @@ mep_reorg_regmove (rtx insns) if (dump_file) for (insn = insns; insn; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == INSN) + if (NONJUMP_INSN_P (insn)) before++; /* We're looking for (set r2 r1) moves where r1 dies, followed by a @@ -4896,7 +4896,7 @@ mep_reorg_regmove (rtx insns) for (insn = insns; insn; insn = next) { next = next_nonnote_nondebug_insn (insn); - if (GET_CODE (insn) != INSN) + if (! NONJUMP_INSN_P (insn)) continue; pat = PATTERN (insn); @@ -4912,7 +4912,7 @@ mep_reorg_regmove (rtx insns) if (dump_file) fprintf (dump_file, "superfluous moves: considering %d\n", INSN_UID (insn)); - while (follow && GET_CODE (follow) == INSN + while (follow && NONJUMP_INSN_P (follow) && GET_CODE (PATTERN (follow)) == SET && !dead_or_set_p (follow, SET_SRC (pat)) && !mep_mentioned_p (PATTERN (follow), SET_SRC (pat), 0) @@ -4925,7 +4925,7 @@ mep_reorg_regmove (rtx insns) if (dump_file) fprintf (dump_file, "\tfollow is %d\n", INSN_UID (follow)); - if (follow && GET_CODE (follow) == INSN + if (follow && NONJUMP_INSN_P (follow) && GET_CODE (PATTERN (follow)) == SET && find_regno_note (follow, REG_DEAD, REGNO (SET_DEST (pat)))) { @@ -5523,8 +5523,7 @@ mep_reorg_erepeat (rtx insns) count = simplejump_p (insn) ? 0 : 1; for (prev = PREV_INSN (insn); prev; prev = PREV_INSN (prev)) { - if (GET_CODE (prev) == CALL_INSN - || BARRIER_P (prev)) + if (CALL_P (prev) || BARRIER_P (prev)) break; if (prev == JUMP_LABEL (insn)) @@ -5543,10 +5542,10 @@ mep_reorg_erepeat (rtx insns) *after* the label. */ rtx barrier; for (barrier = PREV_INSN (prev); - barrier && GET_CODE (barrier) == NOTE; + barrier && NOTE_P (barrier); barrier = PREV_INSN (barrier)) ; - if (barrier && GET_CODE (barrier) != BARRIER) + if (barrier && ! BARRIER_P (barrier)) break; } else @@ -5590,10 +5589,9 @@ mep_reorg_erepeat (rtx insns) if (LABEL_NUSES (prev) == 1) { for (user = PREV_INSN (prev); - user && (INSN_P (user) || GET_CODE (user) == NOTE); + user && (INSN_P (user) || NOTE_P (user)); user = PREV_INSN (user)) - if (GET_CODE (user) == JUMP_INSN - && JUMP_LABEL (user) == prev) + if (JUMP_P (user) && JUMP_LABEL (user) == prev) { safe = INSN_UID (user); break; @@ -5631,8 +5629,8 @@ mep_jmp_return_reorg (rtx insns) /* Find the fist real insn the jump jumps to. */ label = ret = JUMP_LABEL (insn); while (ret - && (GET_CODE (ret) == NOTE - || GET_CODE (ret) == CODE_LABEL + && (NOTE_P (ret) + || LABEL_P (ret) || GET_CODE (PATTERN (ret)) == USE)) ret = NEXT_INSN (ret); @@ -7018,7 +7016,7 @@ mep_bundle_insns (rtx insns) if (recog_memoized (insn) >= 0 && get_attr_slot (insn) == SLOT_COP) { - if (GET_CODE (insn) == JUMP_INSN + if (JUMP_P (insn) || ! last || recog_memoized (last) < 0 || get_attr_slot (last) != SLOT_CORE diff --git a/gcc/config/microblaze/linux.h b/gcc/config/microblaze/linux.h index eca777640a7..a7b7a1adcfa 100644 --- a/gcc/config/microblaze/linux.h +++ b/gcc/config/microblaze/linux.h @@ -22,6 +22,9 @@ #undef TARGET_SUPPORTS_PIC #define TARGET_SUPPORTS_PIC 1 +#undef TLS_NEEDS_GOT +#define TLS_NEEDS_GOT 1 + #define DYNAMIC_LINKER "/lib/ld.so.1" #undef SUBTARGET_EXTRA_SPECS #define SUBTARGET_EXTRA_SPECS \ diff --git a/gcc/config/microblaze/microblaze-protos.h b/gcc/config/microblaze/microblaze-protos.h index e19939f0930..34be76ffa63 100644 --- a/gcc/config/microblaze/microblaze-protos.h +++ b/gcc/config/microblaze/microblaze-protos.h @@ -50,6 +50,10 @@ extern void microblaze_declare_object (FILE *, const char *, const char *, const char *, int); extern void microblaze_asm_output_ident (const char *); extern int microblaze_legitimate_pic_operand (rtx); +extern bool microblaze_tls_referenced_p (rtx); +extern int symbol_mentioned_p (rtx); +extern int label_mentioned_p (rtx); +extern bool microblaze_cannot_force_const_mem (enum machine_mode, rtx); #endif /* RTX_CODE */ /* Declare functions in microblaze-c.c. */ diff --git a/gcc/config/microblaze/microblaze.c b/gcc/config/microblaze/microblaze.c index 3a5299410b9..c121c2baec3 100644 --- a/gcc/config/microblaze/microblaze.c +++ b/gcc/config/microblaze/microblaze.c @@ -84,7 +84,8 @@ enum microblaze_address_type ADDRESS_CONST_INT, ADDRESS_SYMBOLIC, ADDRESS_GOTOFF, - ADDRESS_PLT + ADDRESS_PLT, + ADDRESS_TLS }; /* Classifies symbols @@ -98,6 +99,15 @@ enum microblaze_symbol_type SYMBOL_TYPE_GENERAL }; +/* TLS Address Type. */ +enum tls_reloc { + TLS_GD, + TLS_LDM, + TLS_DTPREL, + TLS_IE, + TLS_LE +}; + /* Classification of a MicroBlaze address. */ struct microblaze_address_info { @@ -108,6 +118,7 @@ struct microblaze_address_info rtx offset; /* Contains valid values on ADDRESS_CONST_INT and ADDRESS_REG. */ rtx symbol; /* Contains valid values on ADDRESS_SYMBOLIC. */ enum microblaze_symbol_type symbol_type; + enum tls_reloc tls_type; }; /* Structure to be filled in by compute_frame_size with register @@ -215,6 +226,11 @@ static int microblaze_interrupt_function_p (tree); section *sdata2_section; +#ifdef HAVE_AS_TLS +#undef TARGET_HAVE_TLS +#define TARGET_HAVE_TLS true +#endif + /* Return truth value if a CONST_DOUBLE is ok to be a legitimate constant. */ static bool microblaze_const_double_ok (rtx op, enum machine_mode mode) @@ -287,6 +303,9 @@ simple_memory_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED) plus0 = XEXP (addr, 0); plus1 = XEXP (addr, 1); + if (GET_CODE (plus0) != REG) + return 0; + if (GET_CODE (plus0) == REG && GET_CODE (plus1) == CONST_INT && SMALL_INT (plus1)) { @@ -386,6 +405,225 @@ microblaze_valid_base_register_p (rtx x, && microblaze_regno_ok_for_base_p (REGNO (x), strict)); } +/* Build the SYMBOL_REF for __tls_get_addr. */ + +static GTY(()) rtx tls_get_addr_libfunc; + +static rtx +get_tls_get_addr (void) +{ + if (!tls_get_addr_libfunc) + tls_get_addr_libfunc = init_one_libfunc ("__tls_get_addr"); + return tls_get_addr_libfunc; +} + +/* Return TRUE if X is a thread-local symbol. */ +bool +microblaze_tls_symbol_p (rtx x) +{ + if (!TARGET_HAVE_TLS) + return false; + + if (GET_CODE (x) != SYMBOL_REF) + return false; + + return SYMBOL_REF_TLS_MODEL (x) != 0; +} + +static int +microblaze_tls_operand_p_1 (rtx *x, void *data ATTRIBUTE_UNUSED) +{ + if (GET_CODE (*x) == SYMBOL_REF) + return SYMBOL_REF_TLS_MODEL (*x) != 0; + + /* Don't recurse into UNSPEC_TLS looking for TLS symbols; these are + TLS offsets, not real symbol references. */ + if (GET_CODE (*x) == UNSPEC && XINT (*x, 1) == UNSPEC_TLS) + return -1; + + return 0; +} + +/* Return TRUE if X contains any TLS symbol references. */ + +bool +microblaze_tls_referenced_p (rtx x) +{ + if (!TARGET_HAVE_TLS) + return false; + + return for_each_rtx (&x, microblaze_tls_operand_p_1, NULL); +} + +bool +microblaze_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x) +{ + return microblaze_tls_referenced_p(x); +} + +/* Return TRUE if X references a SYMBOL_REF. */ +int +symbol_mentioned_p (rtx x) +{ + const char * fmt; + int i; + + if (GET_CODE (x) == SYMBOL_REF) + return 1; + + /* UNSPEC entries for a symbol include the SYMBOL_REF, but they + are constant offsets, not symbols. */ + if (GET_CODE (x) == UNSPEC) + return 0; + + fmt = GET_RTX_FORMAT (GET_CODE (x)); + + for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--) + { + if (fmt[i] == 'E') + { + int j; + + for (j = XVECLEN (x, i) - 1; j >= 0; j--) + if (symbol_mentioned_p (XVECEXP (x, i, j))) + return 1; + } + else if (fmt[i] == 'e' && symbol_mentioned_p (XEXP (x, i))) + return 1; + } + + return 0; +} + +/* Return TRUE if X references a LABEL_REF. */ +int +label_mentioned_p (rtx x) +{ + const char * fmt; + int i; + + if (GET_CODE (x) == LABEL_REF) + return 1; + + /* UNSPEC entries for a symbol include a LABEL_REF for the referencing + instruction, but they are constant offsets, not symbols. */ + if (GET_CODE (x) == UNSPEC) + return 0; + + fmt = GET_RTX_FORMAT (GET_CODE (x)); + for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--) + { + if (fmt[i] == 'E') + { + int j; + + for (j = XVECLEN (x, i) - 1; j >= 0; j--) + if (label_mentioned_p (XVECEXP (x, i, j))) + return 1; + } + else if (fmt[i] == 'e' && label_mentioned_p (XEXP (x, i))) + return 1; + } + + return 0; +} + +int +tls_mentioned_p (rtx x) +{ + switch (GET_CODE (x)) + { + case CONST: + return tls_mentioned_p (XEXP (x, 0)); + + case UNSPEC: + if (XINT (x, 1) == UNSPEC_TLS) + return 1; + + default: + return 0; + } +} + +static rtx +load_tls_operand (rtx x, rtx reg) +{ + rtx tmp; + + if (reg == NULL_RTX) + reg = gen_reg_rtx (Pmode); + + tmp = gen_rtx_CONST (Pmode, x); + + emit_insn (gen_rtx_SET (VOIDmode, reg, + gen_rtx_PLUS (Pmode, pic_offset_table_rtx, tmp))); + + return reg; +} + +static rtx +microblaze_call_tls_get_addr (rtx x, rtx reg, rtx *valuep, int reloc) +{ + rtx insns, tls_entry; + + df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); + + start_sequence (); + + tls_entry = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, x, GEN_INT (reloc)), + UNSPEC_TLS); + + reg = load_tls_operand (tls_entry, reg); + + *valuep = emit_library_call_value (get_tls_get_addr (), NULL_RTX, + LCT_PURE, /* LCT_CONST? */ + Pmode, 1, reg, Pmode); + + insns = get_insns (); + end_sequence (); + + return insns; +} + +rtx +microblaze_legitimize_tls_address(rtx x, rtx reg) +{ + rtx dest, insns, ret, eqv, addend; + enum tls_model model; + model = SYMBOL_REF_TLS_MODEL (x); + + switch (model) + { + case TLS_MODEL_LOCAL_DYNAMIC: + case TLS_MODEL_GLOBAL_DYNAMIC: + case TLS_MODEL_INITIAL_EXEC: + insns = microblaze_call_tls_get_addr (x, reg, &ret, TLS_GD); + dest = gen_reg_rtx (Pmode); + emit_libcall_block (insns, dest, ret, x); + break; + + case TLS_MODEL_LOCAL_EXEC: + insns = microblaze_call_tls_get_addr (x, reg, &ret, TLS_LDM); + + /* Attach a unique REG_EQUIV, to allow the RTL optimizers to + share the LDM result with other LD model accesses. */ + eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const1_rtx), UNSPEC_TLS); + dest = gen_reg_rtx (Pmode); + emit_libcall_block (insns, dest, ret, eqv); + + /* Load the addend. */ + addend = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, x, GEN_INT (TLS_DTPREL)), + UNSPEC_TLS); + addend = force_reg (SImode, gen_rtx_CONST (SImode, addend)); + dest = gen_rtx_PLUS (Pmode, dest, addend); + break; + + default: + gcc_unreachable (); + } + return dest; +} + static bool microblaze_classify_unspec (struct microblaze_address_info *info, rtx x) { @@ -401,6 +639,11 @@ microblaze_classify_unspec (struct microblaze_address_info *info, rtx x) { info->type = ADDRESS_PLT; } + else if (XINT (x, 1) == UNSPEC_TLS) + { + info->type = ADDRESS_TLS; + info->tls_type = tls_reloc INTVAL(XVECEXP(x, 0, 1)); + } else { return false; @@ -431,7 +674,12 @@ static int get_base_reg (rtx x) { tree decl; - int base_reg = (flag_pic ? MB_ABI_PIC_ADDR_REGNUM : MB_ABI_BASE_REGNUM); + int base_reg; + + if (!flag_pic || microblaze_tls_symbol_p(x)) + base_reg = MB_ABI_BASE_REGNUM; + else if (flag_pic) + base_reg = MB_ABI_PIC_ADDR_REGNUM; if (TARGET_XLGPOPT && GET_CODE (x) == SYMBOL_REF @@ -509,28 +757,61 @@ microblaze_classify_address (struct microblaze_address_info *info, rtx x, } else if (GET_CODE (xplus1) == UNSPEC) { + /* Need offsettable address. */ + if (GET_MODE_SIZE (mode) > UNITS_PER_WORD) + return false; + return microblaze_classify_unspec (info, xplus1); } else if ((GET_CODE (xplus1) == SYMBOL_REF || - GET_CODE (xplus1) == LABEL_REF) && flag_pic == 2) - { - return false; - } - else if (GET_CODE (xplus1) == SYMBOL_REF || - GET_CODE (xplus1) == LABEL_REF || - GET_CODE (xplus1) == CONST) + GET_CODE (xplus1) == LABEL_REF)) { - if (GET_CODE (XEXP (xplus1, 0)) == UNSPEC) - return microblaze_classify_unspec (info, XEXP (xplus1, 0)); - else if (flag_pic == 2) - { - return false; - } + if (flag_pic == 2 || microblaze_tls_symbol_p(xplus1)) + return false; info->type = ADDRESS_SYMBOLIC; info->symbol = xplus1; info->symbol_type = SYMBOL_TYPE_GENERAL; return true; } + else if (GET_CODE (xplus1) == CONST) + { + rtx xconst0 = XEXP(xplus1, 0); + + /* base + unspec. */ + if (GET_CODE (xconst0) == UNSPEC) + { + /* Need offsettable address. */ + if (GET_MODE_SIZE (mode) > UNITS_PER_WORD) + return false; + return microblaze_classify_unspec(info, xconst0); + } + + /* for (plus x const_int) just look at x. */ + if (GET_CODE (xconst0) == PLUS + && GET_CODE (XEXP (xconst0, 1)) == CONST_INT + && SMALL_INT (XEXP (xconst0, 1))) + { + /* This is ok as info->symbol is set to xplus1 the full + const-expression below. */ + xconst0 = XEXP (xconst0, 0); + } + + if (GET_CODE (xconst0) == SYMBOL_REF + || GET_CODE (xconst0) == LABEL_REF) + { + if (flag_pic == 2 || microblaze_tls_symbol_p(xconst0)) + return false; + + info->type = ADDRESS_SYMBOLIC; + info->symbol = xplus1; + info->symbol_type = SYMBOL_TYPE_GENERAL; + return true; + } + + /* Not base + symbol || base + UNSPEC. */ + return false; + + } else if (GET_CODE (xplus1) == REG && microblaze_valid_index_register_p (xplus1, mode, strict) @@ -562,13 +843,20 @@ microblaze_classify_address (struct microblaze_address_info *info, rtx x, if (GET_CODE (x) == CONST) { - return !(flag_pic && pic_address_needs_scratch (x)); - } - else if (flag_pic == 2) - { - return false; + if (GET_CODE (XEXP (x, 0)) == UNSPEC) + { + info->regA = gen_rtx_raw_REG (mode, + get_base_reg (XVECEXP (XEXP (x,0), 0, 0))); + return microblaze_classify_unspec (info, XEXP (x, 0)); + } + return !(flag_pic && pic_address_needs_scratch (x)); } + if (flag_pic == 2) + return false; + else if (microblaze_tls_symbol_p(x)) + return false; + return true; } @@ -616,11 +904,10 @@ microblaze_valid_pic_const (rtx x) int microblaze_legitimate_pic_operand (rtx x) { - struct microblaze_address_info addr; - - if (pic_address_needs_scratch (x)) + if (flag_pic == 2 && (symbol_mentioned_p(x) || label_mentioned_p(x))) return 0; - if (!microblaze_valid_pic_const(x)) + + if (microblaze_tls_referenced_p(x)) return 0; return 1; @@ -706,7 +993,7 @@ microblaze_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, return result; } - if (code0 == REG && REG_OK_FOR_BASE_P (xplus0) && flag_pic == 2) + if (code0 == REG && REG_OK_FOR_BASE_P (xplus0)) { if (reload_in_progress) df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); @@ -717,26 +1004,58 @@ microblaze_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, } if (code1 == SYMBOL_REF) { - result = - gen_rtx_UNSPEC (Pmode, gen_rtvec (1, xplus1), UNSPEC_GOTOFF); - result = gen_rtx_CONST (Pmode, result); - result = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, result); - result = gen_const_mem (Pmode, result); - result = gen_rtx_PLUS (Pmode, xplus0, result); - return result; + if (microblaze_tls_symbol_p(xplus1)) + { + rtx tls_ref, reg; + reg = gen_reg_rtx (Pmode); + + tls_ref = microblaze_legitimize_tls_address (xplus1, + NULL_RTX); + emit_move_insn (reg, tls_ref); + + result = gen_rtx_PLUS (Pmode, xplus0, reg); + + return result; + } + else if (flag_pic == 2) + { + rtx pic_ref, reg; + reg = gen_reg_rtx (Pmode); + + pic_ref = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, xplus1), + UNSPEC_GOTOFF); + pic_ref = gen_rtx_CONST (Pmode, pic_ref); + pic_ref = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, pic_ref); + pic_ref = gen_const_mem (Pmode, pic_ref); + emit_move_insn (reg, pic_ref); + result = gen_rtx_PLUS (Pmode, xplus0, reg); + return result; + } } } } if (GET_CODE (xinsn) == SYMBOL_REF) { - if (reload_in_progress) - df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); - result = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, xinsn), UNSPEC_GOTOFF); - result = gen_rtx_CONST (Pmode, result); - result = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, result); - result = gen_const_mem (Pmode, result); - return result; + rtx reg; + if (microblaze_tls_symbol_p(xinsn)) + { + reg = microblaze_legitimize_tls_address (xinsn, NULL_RTX); + } + else + { + rtx pic_ref; + + if (reload_in_progress) + df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); + + pic_ref = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, xinsn), UNSPEC_GOTOFF); + pic_ref = gen_rtx_CONST (Pmode, pic_ref); + pic_ref = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, pic_ref); + pic_ref = gen_const_mem (Pmode, pic_ref); + reg = pic_ref; + } + return reg; } return x; @@ -1061,10 +1380,22 @@ microblaze_address_insns (rtx x, enum machine_mode mode) else return 2; case ADDRESS_REG_INDEX: - case ADDRESS_SYMBOLIC: return 1; + case ADDRESS_SYMBOLIC: case ADDRESS_GOTOFF: return 2; + case ADDRESS_TLS: + switch (addr.tls_type) + { + case TLS_GD: + return 2; + case TLS_LDM: + return 2; + case TLS_DTPREL: + return 1; + default : + abort(); + } default: break; } @@ -1088,13 +1419,18 @@ microblaze_address_cost (rtx addr, enum machine_mode mode ATTRIBUTE_UNUSED, int pic_address_needs_scratch (rtx x) { - /* An address which is a symbolic plus a non SMALL_INT needs a temp reg. */ - if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS - && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF - && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT - && (flag_pic == 2 || !SMALL_INT (XEXP (XEXP (x, 0), 1)))) - return 1; + if (GET_CODE (x) == CONST && GET_CODE (XEXP (x,0)) == PLUS) + { + rtx p0, p1; + p0 = XEXP (XEXP (x, 0), 0); + p1 = XEXP (XEXP (x, 0), 1); + + if ((GET_CODE (p0) == SYMBOL_REF || GET_CODE (p0) == LABEL_REF) + && (GET_CODE (p1) == CONST_INT) + && (flag_pic == 2 || microblaze_tls_symbol_p (p0) || !SMALL_INT (p1))) + return 1; + } return 0; } @@ -1918,6 +2254,7 @@ print_operand (FILE * file, rtx op, int letter) case ADDRESS_CONST_INT: case ADDRESS_SYMBOLIC: case ADDRESS_GOTOFF: + case ADDRESS_TLS: fputs ("i", file); break; case ADDRESS_REG_INDEX: @@ -2034,10 +2371,19 @@ print_operand (FILE * file, rtx op, int letter) else if (letter == 't') fputs (code == EQ ? "t" : "f", file); - else if (code == CONST && GET_CODE (XEXP (op, 0)) == REG) + else if (code == CONST + && ((GET_CODE (XEXP (op, 0)) == REG) + || (GET_CODE (XEXP (op, 0)) == UNSPEC))) { print_operand (file, XEXP (op, 0), letter); } + else if (code == CONST + && (GET_CODE (XEXP (op, 0)) == PLUS) + && (GET_CODE (XEXP (XEXP (op, 0), 0)) == REG) + && (GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST)) + { + print_operand_address (file, XEXP (op, 0)); + } else if (letter == 'm') fprintf (file, HOST_WIDE_INT_PRINT_DEC, (1L << INTVAL (op))); else @@ -2098,6 +2444,7 @@ print_operand_address (FILE * file, rtx addr) case ADDRESS_SYMBOLIC: case ADDRESS_GOTOFF: case ADDRESS_PLT: + case ADDRESS_TLS: if (info.regA) fprintf (file, "%s,", reg_names[REGNO (info.regA)]); output_addr_const (file, info.symbol); @@ -2109,6 +2456,24 @@ print_operand_address (FILE * file, rtx addr) { fputs ("@PLT", file); } + else if (type == ADDRESS_TLS) + { + switch (info.tls_type) + { + case TLS_GD: + fputs ("@TLSGD", file); + break; + case TLS_LDM: + fputs ("@TLSLDM", file); + break; + case TLS_DTPREL: + fputs ("@TLSDTPREL", file); + break; + default : + abort(); + break; + } + } break; case ADDRESS_INVALID: fatal_insn ("invalid address", addr); @@ -2471,7 +2836,8 @@ microblaze_expand_prologue (void) } } - if (flag_pic == 2 && df_regs_ever_live_p (MB_ABI_PIC_ADDR_REGNUM)) + if ((flag_pic == 2 || TLS_NEEDS_GOT ) + && df_regs_ever_live_p (MB_ABI_PIC_ADDR_REGNUM)) { SET_REGNO (pic_offset_table_rtx, MB_ABI_PIC_ADDR_REGNUM); emit_insn (gen_set_got (pic_offset_table_rtx)); /* setting GOT. */ @@ -2701,83 +3067,62 @@ expand_pic_symbol_ref (enum machine_mode mode ATTRIBUTE_UNUSED, rtx op) bool microblaze_expand_move (enum machine_mode mode, rtx operands[]) { + rtx op0, op1; + + op0 = operands[0]; + op1 = operands[1]; + + if (!register_operand (op0, SImode) + && !register_operand (op1, SImode) + && (GET_CODE (op1) != CONST_INT || INTVAL (op1) != 0)) + { + rtx temp = force_reg (SImode, op1); + emit_move_insn (op0, temp); + return true; + } /* If operands[1] is a constant address invalid for pic, then we need to handle it just like LEGITIMIZE_ADDRESS does. */ - if (flag_pic) + if (GET_CODE (op1) == SYMBOL_REF || GET_CODE (op1) == LABEL_REF) { - if (GET_CODE (operands[0]) == MEM) + rtx result; + if (microblaze_tls_symbol_p(op1)) { - rtx addr = XEXP (operands[0], 0); - if (GET_CODE (addr) == SYMBOL_REF) - { - rtx ptr_reg, result; - - if (reload_in_progress) - df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); - - addr = expand_pic_symbol_ref (mode, addr); - ptr_reg = gen_reg_rtx (Pmode); - emit_move_insn (ptr_reg, addr); - result = gen_rtx_MEM (mode, ptr_reg); - operands[0] = result; - } + result = microblaze_legitimize_tls_address (op1, NULL_RTX); + emit_move_insn (op0, result); + return true; } - if (GET_CODE (operands[1]) == SYMBOL_REF - || GET_CODE (operands[1]) == LABEL_REF) + else if (flag_pic) { - rtx result; if (reload_in_progress) df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); - result = expand_pic_symbol_ref (mode, operands[1]); - if (GET_CODE (operands[0]) != REG) - { - rtx ptr_reg = gen_reg_rtx (Pmode); - emit_move_insn (ptr_reg, result); - emit_move_insn (operands[0], ptr_reg); - } - else - { - emit_move_insn (operands[0], result); - } + result = expand_pic_symbol_ref (mode, op1); + emit_move_insn (op0, result); return true; } - else if (GET_CODE (operands[1]) == MEM && - GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF) - { - rtx result; - rtx ptr_reg; - if (reload_in_progress) - df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); - result = expand_pic_symbol_ref (mode, XEXP (operands[1], 0)); + } + /* Handle Case of (const (plus symbol const_int)). */ + if (GET_CODE (op1) == CONST && GET_CODE (XEXP (op1,0)) == PLUS) + { + rtx p0, p1; - ptr_reg = gen_reg_rtx (Pmode); + p0 = XEXP (XEXP (op1, 0), 0); + p1 = XEXP (XEXP (op1, 0), 1); - emit_move_insn (ptr_reg, result); - result = gen_rtx_MEM (mode, ptr_reg); - emit_move_insn (operands[0], result); - return true; - } - else if (pic_address_needs_scratch (operands[1])) + if ((GET_CODE (p1) == CONST_INT) + && ((GET_CODE (p0) == UNSPEC) + || ((GET_CODE (p0) == SYMBOL_REF || GET_CODE (p0) == LABEL_REF) + && (flag_pic == 2 || microblaze_tls_symbol_p (p0) + || !SMALL_INT (p1))))) { - rtx temp = force_reg (SImode, XEXP (XEXP (operands[1], 0), 0)); - rtx temp2 = XEXP (XEXP (operands[1], 0), 1); + rtx temp = force_reg (SImode, p0); + rtx temp2 = p1; - if (reload_in_progress) + if (flag_pic && reload_in_progress) df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true); - emit_move_insn (operands[0], gen_rtx_PLUS (SImode, temp, temp2)); + emit_move_insn (op0, gen_rtx_PLUS (SImode, temp, temp2)); return true; } } - - if ((reload_in_progress | reload_completed) == 0 - && !register_operand (operands[0], SImode) - && !register_operand (operands[1], SImode) - && (GET_CODE (operands[1]) != CONST_INT || INTVAL (operands[1]) != 0)) - { - rtx temp = force_reg (SImode, operands[1]); - emit_move_insn (operands[0], temp); - return true; - } return false; } @@ -3048,10 +3393,40 @@ microblaze_adjust_cost (rtx insn ATTRIBUTE_UNUSED, rtx link, At present, GAS doesn't understand li.[sd], so don't allow it to be generated at present. */ static bool -microblaze_legitimate_constant_p (enum machine_mode mode, rtx x) +microblaze_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x) { - return GET_CODE (x) != CONST_DOUBLE || microblaze_const_double_ok (x, mode); + + if (microblaze_cannot_force_const_mem(mode, x)) + return false; + + if (GET_CODE (x) == CONST_DOUBLE) + { + return microblaze_const_double_ok (x, GET_MODE (x)); + } + + /* Handle Case of (const (plus unspec const_int)). */ + if (GET_CODE (x) == CONST && GET_CODE (XEXP (x,0)) == PLUS) + { + rtx p0, p1; + + p0 = XEXP (XEXP (x, 0), 0); + p1 = XEXP (XEXP (x, 0), 1); + + if (GET_CODE(p1) == CONST_INT) + { + /* Const offset from UNSPEC is not supported. */ + if ((GET_CODE (p0) == UNSPEC)) + return false; + + if ((GET_CODE (p0) == SYMBOL_REF || GET_CODE (p0) == LABEL_REF) + && (microblaze_tls_symbol_p (p0) || !SMALL_INT (p1))) + return false; + } + } + + return true; } + #undef TARGET_ENCODE_SECTION_INFO #define TARGET_ENCODE_SECTION_INFO microblaze_encode_section_info @@ -3068,6 +3443,9 @@ microblaze_legitimate_constant_p (enum machine_mode mode, rtx x) #undef TARGET_RTX_COSTS #define TARGET_RTX_COSTS microblaze_rtx_costs +#undef TARGET_CANNOT_FORCE_CONST_MEM +#define TARGET_CANNOT_FORCE_CONST_MEM microblaze_cannot_force_const_mem + #undef TARGET_ADDRESS_COST #define TARGET_ADDRESS_COST microblaze_address_cost diff --git a/gcc/config/microblaze/microblaze.h b/gcc/config/microblaze/microblaze.h index 8fbe5bf8085..bc4d9a128d1 100644 --- a/gcc/config/microblaze/microblaze.h +++ b/gcc/config/microblaze/microblaze.h @@ -65,6 +65,9 @@ extern enum pipeline_type microblaze_pipe; /* The default is to support PIC. */ #define TARGET_SUPPORTS_PIC 1 +/* The default is to not need GOT for TLS. */ +#define TLS_NEEDS_GOT 0 + /* What is the default setting for -mcpu= . We set it to v4.00.a even though we are actually ahead. This is safest version that has generate code compatible for the original ISA */ @@ -326,9 +329,7 @@ extern char microblaze_hard_regno_mode_ok[][FIRST_PSEUDO_REGISTER]; #define NO_FUNCTION_CSE 1 -#define PIC_OFFSET_TABLE_REGNUM \ - (flag_pic ? (GP_REG_FIRST + MB_ABI_PIC_ADDR_REGNUM) : \ - INVALID_REGNUM) +#define PIC_OFFSET_TABLE_REGNUM (GP_REG_FIRST + MB_ABI_PIC_ADDR_REGNUM) enum reg_class { diff --git a/gcc/config/microblaze/microblaze.md b/gcc/config/microblaze/microblaze.md index 02857875022..3618cad524b 100644 --- a/gcc/config/microblaze/microblaze.md +++ b/gcc/config/microblaze/microblaze.md @@ -40,6 +40,7 @@ (UNSPEC_PLT 103) ;; jump table (UNSPEC_CMP 104) ;; signed compare (UNSPEC_CMPU 105) ;; unsigned compare + (UNSPEC_TLS 106) ;; jump table ]) @@ -459,7 +460,7 @@ (define_insn "addsi3" [(set (match_operand:SI 0 "register_operand" "=d,d,d") (plus:SI (match_operand:SI 1 "reg_or_0_operand" "%dJ,dJ,dJ") - (match_operand:SI 2 "arith_operand" "d,I,i")))] + (match_operand:SI 2 "arith_plus_operand" "d,I,i")))] "" "@ addk\t%0,%z1,%2 @@ -892,8 +893,8 @@ (define_insn "*movdi_internal" - [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,d,d,d,R,m") - (match_operand:DI 1 "general_operand" " d,i,J,R,m,d,d"))] + [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,d,d,d,R,o") + (match_operand:DI 1 "general_operand" " d,i,J,R,o,d,d"))] "" { switch (which_alternative) @@ -999,13 +1000,9 @@ (set_attr "length" "4")]) (define_insn "*movsi_internal2" - [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d, d,d,R, T") - (match_operand:SI 1 "move_operand" " d,I,Mnis,R,m,dJ,dJ"))] - "(register_operand (operands[0], SImode) - || register_operand (operands[1], SImode) - || (GET_CODE (operands[1]) == CONST_INT && INTVAL (operands[1]) == 0)) - && (flag_pic != 2 || (GET_CODE (operands[1]) != SYMBOL_REF - && GET_CODE (operands[1]) != LABEL_REF))" + [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,d, d,d,R,m") + (match_operand:SI 1 "move_src_operand" " d,I,Mnis,R,m,dJ,dJ"))] + "" "@ addk\t%0,%1,r0 addik\t%0,r0,%1\t# %X1 @@ -1196,7 +1193,7 @@ ;; Applies to both TARGET_SOFT_FLOAT and TARGET_HARD_FLOAT ;; (define_insn "*movdf_internal" - [(set (match_operand:DF 0 "nonimmediate_operand" "=d,d,d,d,To") + [(set (match_operand:DF 0 "nonimmediate_operand" "=d,d,d,d,o") (match_operand:DF 1 "general_operand" "dG,o,F,T,d"))] "" { diff --git a/gcc/config/microblaze/predicates.md b/gcc/config/microblaze/predicates.md index e6e99836024..5fd1bd40372 100644 --- a/gcc/config/microblaze/predicates.md +++ b/gcc/config/microblaze/predicates.md @@ -30,6 +30,52 @@ (and (match_code "const_int,const_double") (match_test "LARGE_INT (op)")))) +(define_predicate "arith_plus_operand" + (match_operand 0 "general_operand") +{ + switch (GET_CODE (op)) + { + default: + return 0; + case CONST_INT: + case REG: + return 1; + case SYMBOL_REF: + case LABEL_REF: + if (flag_pic || microblaze_tls_referenced_p(op)) + return 0; + return 1; + case CONST: + { + rtx const0; + const0 = XEXP (op, 0); + + switch (GET_CODE(const0)) + { + default: + return 0; + case UNSPEC : + return 1; + + case PLUS : + { + rtx p0, p1; + p0 = XEXP (const0, 0); + p1 = XEXP (const0, 1); + + if ((GET_CODE(p0) == SYMBOL_REF + || GET_CODE (p0) == LABEL_REF) + && GET_CODE(p1) == CONST_INT) + { + return arith_plus_operand (p0, GET_MODE(p0)); + } + } + } + } + } + return 0; +}) + (define_predicate "const_0_operand" (and (match_code "const_int,const_double") (match_test "op == CONST0_RTX (GET_MODE (op))"))) @@ -54,14 +100,21 @@ (match_test "GET_CODE (op) == REG || GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == CONST_INT"))) ;; Return if OPERAND is valid as a source operand for a move instruction. -(define_predicate "move_operand" +(define_predicate "move_src_operand" (and ( not ( and (match_code "plus") (not (match_test "(GET_CODE (XEXP (op, 0)) == REG) ^ (GET_CODE (XEXP (op,1)) == REG)")) ) ) - (match_operand 0 "general_operand"))) + (match_operand 0 "general_operand")) +{ + if (microblaze_tls_referenced_p(op) + || (flag_pic && (symbol_mentioned_p(op) || label_mentioned_p(op)))) + return false; + + return true; +}) ;; Test for valid PIC call operand (define_predicate "call_insn_plt_operand" diff --git a/gcc/config/mips/constraints.md b/gcc/config/mips/constraints.md index 71ec938d85b..e73c440e1f4 100644 --- a/gcc/config/mips/constraints.md +++ b/gcc/config/mips/constraints.md @@ -43,6 +43,9 @@ (define_register_constraint "b" "ALL_REGS" "@internal") +(define_register_constraint "u" "M16_REGS" + "@internal") + ;; MIPS16 code always calls through a MIPS16 register; see mips_emit_call_insn ;; for details. (define_register_constraint "c" "TARGET_MIPS16 ? M16_REGS @@ -170,21 +173,40 @@ (and (match_operand 0 "call_insn_operand") (match_test "CONSTANT_P (op)"))) -(define_constraint "T" +(define_constraint "Udb7" "@internal - A constant @code{move_operand} that cannot be safely loaded into @code{$25} - using @code{la}." - (and (match_operand 0 "move_operand") - (match_test "CONSTANT_P (op)") - (match_test "mips_dangerous_for_la25_p (op)"))) + A decremented unsigned constant of 7 bits." + (match_operand 0 "db7_operand")) -(define_constraint "U" +(define_constraint "Uead" "@internal - A constant @code{move_operand} that can be safely loaded into @code{$25} - using @code{la}." - (and (match_operand 0 "move_operand") - (match_test "CONSTANT_P (op)") - (not (match_test "mips_dangerous_for_la25_p (op)")))) + A microMIPS encoded ADDIUR2 immediate operand." + (match_operand 0 "addiur2_operand")) + +(define_constraint "Uean" + "@internal + A microMIPS encoded ANDI operand." + (match_operand 0 "andi16_operand")) + +(define_constraint "Uesp" + "@internal + A microMIPS encoded ADDIUSP operand." + (match_operand 0 "addiusp_operand")) + +(define_constraint "Uib3" + "@internal + An unsigned, incremented constant of 3 bits." + (match_operand 0 "ib3_operand")) + +(define_constraint "Uuw6" + "@internal + An unsigned constant of 6 bits, shifted left two places." + (match_operand 0 "uw6_operand")) + +(define_constraint "Usb4" + "@internal + A signed constant of 4 bits." + (match_operand 0 "sb4_operand")) (define_memory_constraint "W" "@internal @@ -220,6 +242,22 @@ "@internal" (match_operand 0 "qi_mask_operand")) +(define_constraint "Yd" + "@internal + A constant @code{move_operand} that can be safely loaded into @code{$25} + using @code{la}." + (and (match_operand 0 "move_operand") + (match_test "CONSTANT_P (op)") + (not (match_test "mips_dangerous_for_la25_p (op)")))) + +(define_constraint "Yf" + "@internal + A constant @code{move_operand} that cannot be safely loaded into @code{$25} + using @code{la}." + (and (match_operand 0 "move_operand") + (match_test "CONSTANT_P (op)") + (match_test "mips_dangerous_for_la25_p (op)"))) + (define_constraint "Yh" "@internal" (match_operand 0 "hi_mask_operand")) @@ -232,7 +270,59 @@ "@internal" (match_operand 0 "low_bitmask_operand")) +(define_memory_constraint "ZC" + "When compiling microMIPS code, this constraint matches a memory operand + whose address is formed from a base register and a 12-bit offset. These + operands can be used for microMIPS instructions such as @code{ll} and + @code{sc}. When not compiling for microMIPS code, @code{ZC} is + equivalent to @code{R}." + (and (match_code "mem") + (if_then_else + (match_test "TARGET_MICROMIPS") + (match_test "umips_12bit_offset_address_p (XEXP (op, 0), mode)") + (match_test "mips_address_insns (XEXP (op, 0), mode, false)")))) + +(define_address_constraint "ZD" + "When compiling microMIPS code, this constraint matches an address operand + that is formed from a base register and a 12-bit offset. These operands + can be used for microMIPS instructions such as @code{prefetch}. When + not compiling for microMIPS code, @code{ZD} is equivalent to @code{p}." + (if_then_else (match_test "TARGET_MICROMIPS") + (match_test "umips_12bit_offset_address_p (op, mode)") + (match_test "mips_address_insns (op, mode, false)"))) + (define_memory_constraint "ZR" "@internal An address valid for loading/storing register exclusive" (match_operand 0 "mem_noofs_operand")) + +(define_memory_constraint "ZS" + "@internal + A microMIPS memory operand for use with the LWSP/SWSP insns." + (and (match_code "mem") + (match_operand 0 "lwsp_swsp_operand"))) + +(define_memory_constraint "ZT" + "@internal + A microMIPS memory operand for use with the LW16/SW16 insns." + (and (match_code "mem") + (match_operand 0 "lw16_sw16_operand"))) + +(define_memory_constraint "ZU" + "@internal + A microMIPS memory operand for use with the LHU16/SH16 insns." + (and (match_code "mem") + (match_operand 0 "lhu16_sh16_operand"))) + +(define_memory_constraint "ZV" + "@internal + A microMIPS memory operand for use with the SB16 insn." + (and (match_code "mem") + (match_operand 0 "sb16_operand"))) + +(define_memory_constraint "ZW" + "@internal + A microMIPS memory operand for use with the LBU16 insn." + (and (match_code "mem") + (match_operand 0 "lbu16_operand"))) + diff --git a/gcc/config/mips/micromips.md b/gcc/config/mips/micromips.md index e69de29bb2d..4b7a4a7013f 100644 --- a/gcc/config/mips/micromips.md +++ b/gcc/config/mips/micromips.md @@ -0,0 +1,125 @@ +;; Copyright (C) 2013 Free Software Foundation, Inc. +;; +;; micromips.md Machine Description for the microMIPS instruction set +;; This file is part of GCC. + +;; GCC 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. + +;; GCC 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 GCC; see the file COPYING3. If not see +;; <http://www.gnu.org/licenses/>. + +(define_insn "*store_word_multiple" + [(match_parallel 0 "" + [(set (match_operand:SI 1 "memory_operand") + (match_operand:SI 2 "register_operand"))])] + "TARGET_MICROMIPS + && umips_save_restore_pattern_p (true, operands[0])" + { return umips_output_save_restore (true, operands[0]); } + [(set_attr "type" "multimem") + (set_attr "mode" "SI") + (set_attr "can_delay" "no")]) + +(define_insn "*load_word_multiple" + [(match_parallel 0 "" + [(set (match_operand:SI 1 "register_operand") + (match_operand:SI 2 "memory_operand"))])] + "TARGET_MICROMIPS + && umips_save_restore_pattern_p (false, operands[0])" + { return umips_output_save_restore (false, operands[0]); } + [(set_attr "type" "multimem") + (set_attr "mode" "SI") + (set_attr "can_delay" "no")]) + +;; For LWP. +(define_peephole2 + [(set (match_operand:SI 0 "d_operand" "") + (match_operand:SI 1 "non_volatile_mem_operand" "")) + (set (match_operand:SI 2 "d_operand" "") + (match_operand:SI 3 "non_volatile_mem_operand" ""))] + "TARGET_MICROMIPS + && umips_load_store_pair_p (true, operands)" + [(parallel [(set (match_dup 0) (match_dup 1)) + (set (match_dup 2) (match_dup 3))])]) + +;; The behavior of the LWP insn is undefined if placed in a delay slot. +(define_insn "*lwp" + [(parallel [(set (match_operand:SI 0 "d_operand") + (match_operand:SI 1 "non_volatile_mem_operand")) + (set (match_operand:SI 2 "d_operand") + (match_operand:SI 3 "non_volatile_mem_operand"))])] + + "TARGET_MICROMIPS + && umips_load_store_pair_p (true, operands)" +{ + umips_output_load_store_pair (true, operands); + return ""; +} + [(set_attr "type" "load") + (set_attr "mode" "SI") + (set_attr "can_delay" "no")]) + +;; For SWP. +(define_peephole2 + [(set (match_operand:SI 0 "non_volatile_mem_operand" "") + (match_operand:SI 1 "d_operand" "")) + (set (match_operand:SI 2 "non_volatile_mem_operand" "") + (match_operand:SI 3 "d_operand" ""))] + "TARGET_MICROMIPS + && umips_load_store_pair_p (false, operands)" + [(parallel [(set (match_dup 0) (match_dup 1)) + (set (match_dup 2) (match_dup 3))])]) + +;; The behavior of the SWP insn is undefined if placed in a delay slot. +(define_insn "*swp" + [(parallel [(set (match_operand:SI 0 "non_volatile_mem_operand") + (match_operand:SI 1 "d_operand")) + (set (match_operand:SI 2 "non_volatile_mem_operand") + (match_operand:SI 3 "d_operand"))])] + + "TARGET_MICROMIPS + && umips_load_store_pair_p (false, operands)" +{ + umips_output_load_store_pair (false, operands); + return ""; +} + [(set_attr "type" "store") + (set_attr "mode" "SI") + (set_attr "can_delay" "no")]) + +;; For MOVEP. +(define_peephole2 + [(set (match_operand:MOVEP1 0 "register_operand" "") + (match_operand:MOVEP1 1 "movep_src_operand" "")) + (set (match_operand:MOVEP2 2 "register_operand" "") + (match_operand:MOVEP2 3 "movep_src_operand" ""))] + "TARGET_MICROMIPS + && umips_movep_target_p (operands[0], operands[2])" + [(parallel [(set (match_dup 0) (match_dup 1)) + (set (match_dup 2) (match_dup 3))])]) + +;; The behavior of the MOVEP insn is undefined if placed in a delay slot. +(define_insn "*movep<MOVEP1:mode><MOVEP2:mode>" + [(parallel [(set (match_operand:MOVEP1 0 "register_operand") + (match_operand:MOVEP1 1 "movep_src_operand")) + (set (match_operand:MOVEP2 2 "register_operand") + (match_operand:MOVEP2 3 "movep_src_operand"))])] + "TARGET_MICROMIPS + && umips_movep_target_p (operands[0], operands[2])" +{ + if (REGNO (operands[0]) < REGNO (operands[2])) + return "movep\t%0,%2,%z1,%z3"; + else + return "movep\t%2,%0,%z3,%z1"; +} + [(set_attr "type" "move") + (set_attr "mode" "<MODE>") + (set_attr "can_delay" "no")]) diff --git a/gcc/config/mips/mips-cpus.def b/gcc/config/mips/mips-cpus.def index 93c305a7c7f..1cc19999373 100644 --- a/gcc/config/mips/mips-cpus.def +++ b/gcc/config/mips/mips-cpus.def @@ -92,6 +92,8 @@ MIPS_CPU ("4ksc", PROCESSOR_4KC, 32, 0) /* MIPS32 Release 2 processors. */ MIPS_CPU ("m4k", PROCESSOR_M4K, 33, 0) +MIPS_CPU ("m14kc", PROCESSOR_M4K, 33, 0) +MIPS_CPU ("m14k", PROCESSOR_M4K, 33, 0) MIPS_CPU ("4kec", PROCESSOR_4KC, 33, 0) MIPS_CPU ("4kem", PROCESSOR_4KC, 33, 0) MIPS_CPU ("4kep", PROCESSOR_4KP, 33, 0) diff --git a/gcc/config/mips/mips-protos.h b/gcc/config/mips/mips-protos.h index 8560bb7e9dd..3aaf69a7804 100644 --- a/gcc/config/mips/mips-protos.h +++ b/gcc/config/mips/mips-protos.h @@ -350,6 +350,17 @@ extern void mips_expand_vec_reduc (rtx, rtx, rtx (*)(rtx, rtx, rtx)); extern void mips_expand_vec_minmax (rtx, rtx, rtx, rtx (*) (rtx, rtx, rtx), bool); +extern bool mips_signed_immediate_p (unsigned HOST_WIDE_INT, int, int); +extern bool mips_unsigned_immediate_p (unsigned HOST_WIDE_INT, int, int); +extern const char *umips_output_save_restore (bool, rtx); +extern bool umips_save_restore_pattern_p (bool, rtx); +extern bool umips_load_store_pair_p (bool, rtx *); +extern void umips_output_load_store_pair (bool, rtx *); +extern bool umips_movep_target_p (rtx, rtx); +extern bool umips_12bit_offset_address_p (rtx, enum machine_mode); +extern bool lwsp_swsp_address_p (rtx, enum machine_mode); +extern bool m16_based_address_p (rtx, enum machine_mode, + int (*)(rtx_def*, machine_mode)); extern rtx mips_expand_thread_pointer (rtx); extern bool mips_eh_uses (unsigned int); diff --git a/gcc/config/mips/mips-tables.opt b/gcc/config/mips/mips-tables.opt index de9a736452e..0d7fa26510d 100644 --- a/gcc/config/mips/mips-tables.opt +++ b/gcc/config/mips/mips-tables.opt @@ -373,254 +373,260 @@ EnumValue Enum(mips_arch_opt_value) String(m4k) Value(39) Canonical EnumValue -Enum(mips_arch_opt_value) String(4kec) Value(40) Canonical +Enum(mips_arch_opt_value) String(m14kc) Value(40) Canonical EnumValue -Enum(mips_arch_opt_value) String(r4kec) Value(40) +Enum(mips_arch_opt_value) String(m14k) Value(41) Canonical EnumValue -Enum(mips_arch_opt_value) String(4kem) Value(41) Canonical +Enum(mips_arch_opt_value) String(4kec) Value(42) Canonical EnumValue -Enum(mips_arch_opt_value) String(r4kem) Value(41) +Enum(mips_arch_opt_value) String(r4kec) Value(42) EnumValue -Enum(mips_arch_opt_value) String(4kep) Value(42) Canonical +Enum(mips_arch_opt_value) String(4kem) Value(43) Canonical EnumValue -Enum(mips_arch_opt_value) String(r4kep) Value(42) +Enum(mips_arch_opt_value) String(r4kem) Value(43) EnumValue -Enum(mips_arch_opt_value) String(4ksd) Value(43) Canonical +Enum(mips_arch_opt_value) String(4kep) Value(44) Canonical EnumValue -Enum(mips_arch_opt_value) String(r4ksd) Value(43) +Enum(mips_arch_opt_value) String(r4kep) Value(44) EnumValue -Enum(mips_arch_opt_value) String(24kc) Value(44) Canonical +Enum(mips_arch_opt_value) String(4ksd) Value(45) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kc) Value(44) +Enum(mips_arch_opt_value) String(r4ksd) Value(45) EnumValue -Enum(mips_arch_opt_value) String(24kf2_1) Value(45) Canonical +Enum(mips_arch_opt_value) String(24kc) Value(46) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kf2_1) Value(45) +Enum(mips_arch_opt_value) String(r24kc) Value(46) EnumValue -Enum(mips_arch_opt_value) String(24kf) Value(46) Canonical +Enum(mips_arch_opt_value) String(24kf2_1) Value(47) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kf) Value(46) +Enum(mips_arch_opt_value) String(r24kf2_1) Value(47) EnumValue -Enum(mips_arch_opt_value) String(24kf1_1) Value(47) Canonical +Enum(mips_arch_opt_value) String(24kf) Value(48) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kf1_1) Value(47) +Enum(mips_arch_opt_value) String(r24kf) Value(48) EnumValue -Enum(mips_arch_opt_value) String(24kfx) Value(48) Canonical +Enum(mips_arch_opt_value) String(24kf1_1) Value(49) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kfx) Value(48) +Enum(mips_arch_opt_value) String(r24kf1_1) Value(49) EnumValue -Enum(mips_arch_opt_value) String(24kx) Value(49) Canonical +Enum(mips_arch_opt_value) String(24kfx) Value(50) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kx) Value(49) +Enum(mips_arch_opt_value) String(r24kfx) Value(50) EnumValue -Enum(mips_arch_opt_value) String(24kec) Value(50) Canonical +Enum(mips_arch_opt_value) String(24kx) Value(51) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kec) Value(50) +Enum(mips_arch_opt_value) String(r24kx) Value(51) EnumValue -Enum(mips_arch_opt_value) String(24kef2_1) Value(51) Canonical +Enum(mips_arch_opt_value) String(24kec) Value(52) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kef2_1) Value(51) +Enum(mips_arch_opt_value) String(r24kec) Value(52) EnumValue -Enum(mips_arch_opt_value) String(24kef) Value(52) Canonical +Enum(mips_arch_opt_value) String(24kef2_1) Value(53) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kef) Value(52) +Enum(mips_arch_opt_value) String(r24kef2_1) Value(53) EnumValue -Enum(mips_arch_opt_value) String(24kef1_1) Value(53) Canonical +Enum(mips_arch_opt_value) String(24kef) Value(54) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kef1_1) Value(53) +Enum(mips_arch_opt_value) String(r24kef) Value(54) EnumValue -Enum(mips_arch_opt_value) String(24kefx) Value(54) Canonical +Enum(mips_arch_opt_value) String(24kef1_1) Value(55) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kefx) Value(54) +Enum(mips_arch_opt_value) String(r24kef1_1) Value(55) EnumValue -Enum(mips_arch_opt_value) String(24kex) Value(55) Canonical +Enum(mips_arch_opt_value) String(24kefx) Value(56) Canonical EnumValue -Enum(mips_arch_opt_value) String(r24kex) Value(55) +Enum(mips_arch_opt_value) String(r24kefx) Value(56) EnumValue -Enum(mips_arch_opt_value) String(34kc) Value(56) Canonical +Enum(mips_arch_opt_value) String(24kex) Value(57) Canonical EnumValue -Enum(mips_arch_opt_value) String(r34kc) Value(56) +Enum(mips_arch_opt_value) String(r24kex) Value(57) EnumValue -Enum(mips_arch_opt_value) String(34kf2_1) Value(57) Canonical +Enum(mips_arch_opt_value) String(34kc) Value(58) Canonical EnumValue -Enum(mips_arch_opt_value) String(r34kf2_1) Value(57) +Enum(mips_arch_opt_value) String(r34kc) Value(58) EnumValue -Enum(mips_arch_opt_value) String(34kf) Value(58) Canonical +Enum(mips_arch_opt_value) String(34kf2_1) Value(59) Canonical EnumValue -Enum(mips_arch_opt_value) String(r34kf) Value(58) +Enum(mips_arch_opt_value) String(r34kf2_1) Value(59) EnumValue -Enum(mips_arch_opt_value) String(34kf1_1) Value(59) Canonical +Enum(mips_arch_opt_value) String(34kf) Value(60) Canonical EnumValue -Enum(mips_arch_opt_value) String(r34kf1_1) Value(59) +Enum(mips_arch_opt_value) String(r34kf) Value(60) EnumValue -Enum(mips_arch_opt_value) String(34kfx) Value(60) Canonical +Enum(mips_arch_opt_value) String(34kf1_1) Value(61) Canonical EnumValue -Enum(mips_arch_opt_value) String(r34kfx) Value(60) +Enum(mips_arch_opt_value) String(r34kf1_1) Value(61) EnumValue -Enum(mips_arch_opt_value) String(34kx) Value(61) Canonical +Enum(mips_arch_opt_value) String(34kfx) Value(62) Canonical EnumValue -Enum(mips_arch_opt_value) String(r34kx) Value(61) +Enum(mips_arch_opt_value) String(r34kfx) Value(62) EnumValue -Enum(mips_arch_opt_value) String(34kn) Value(62) Canonical +Enum(mips_arch_opt_value) String(34kx) Value(63) Canonical EnumValue -Enum(mips_arch_opt_value) String(r34kn) Value(62) +Enum(mips_arch_opt_value) String(r34kx) Value(63) EnumValue -Enum(mips_arch_opt_value) String(74kc) Value(63) Canonical +Enum(mips_arch_opt_value) String(34kn) Value(64) Canonical EnumValue -Enum(mips_arch_opt_value) String(r74kc) Value(63) +Enum(mips_arch_opt_value) String(r34kn) Value(64) EnumValue -Enum(mips_arch_opt_value) String(74kf2_1) Value(64) Canonical +Enum(mips_arch_opt_value) String(74kc) Value(65) Canonical EnumValue -Enum(mips_arch_opt_value) String(r74kf2_1) Value(64) +Enum(mips_arch_opt_value) String(r74kc) Value(65) EnumValue -Enum(mips_arch_opt_value) String(74kf) Value(65) Canonical +Enum(mips_arch_opt_value) String(74kf2_1) Value(66) Canonical EnumValue -Enum(mips_arch_opt_value) String(r74kf) Value(65) +Enum(mips_arch_opt_value) String(r74kf2_1) Value(66) EnumValue -Enum(mips_arch_opt_value) String(74kf1_1) Value(66) Canonical +Enum(mips_arch_opt_value) String(74kf) Value(67) Canonical EnumValue -Enum(mips_arch_opt_value) String(r74kf1_1) Value(66) +Enum(mips_arch_opt_value) String(r74kf) Value(67) EnumValue -Enum(mips_arch_opt_value) String(74kfx) Value(67) Canonical +Enum(mips_arch_opt_value) String(74kf1_1) Value(68) Canonical EnumValue -Enum(mips_arch_opt_value) String(r74kfx) Value(67) +Enum(mips_arch_opt_value) String(r74kf1_1) Value(68) EnumValue -Enum(mips_arch_opt_value) String(74kx) Value(68) Canonical +Enum(mips_arch_opt_value) String(74kfx) Value(69) Canonical EnumValue -Enum(mips_arch_opt_value) String(r74kx) Value(68) +Enum(mips_arch_opt_value) String(r74kfx) Value(69) EnumValue -Enum(mips_arch_opt_value) String(74kf3_2) Value(69) Canonical +Enum(mips_arch_opt_value) String(74kx) Value(70) Canonical EnumValue -Enum(mips_arch_opt_value) String(r74kf3_2) Value(69) +Enum(mips_arch_opt_value) String(r74kx) Value(70) EnumValue -Enum(mips_arch_opt_value) String(1004kc) Value(70) Canonical +Enum(mips_arch_opt_value) String(74kf3_2) Value(71) Canonical EnumValue -Enum(mips_arch_opt_value) String(r1004kc) Value(70) +Enum(mips_arch_opt_value) String(r74kf3_2) Value(71) EnumValue -Enum(mips_arch_opt_value) String(1004kf2_1) Value(71) Canonical +Enum(mips_arch_opt_value) String(1004kc) Value(72) Canonical EnumValue -Enum(mips_arch_opt_value) String(r1004kf2_1) Value(71) +Enum(mips_arch_opt_value) String(r1004kc) Value(72) EnumValue -Enum(mips_arch_opt_value) String(1004kf) Value(72) Canonical +Enum(mips_arch_opt_value) String(1004kf2_1) Value(73) Canonical EnumValue -Enum(mips_arch_opt_value) String(r1004kf) Value(72) +Enum(mips_arch_opt_value) String(r1004kf2_1) Value(73) EnumValue -Enum(mips_arch_opt_value) String(1004kf1_1) Value(73) Canonical +Enum(mips_arch_opt_value) String(1004kf) Value(74) Canonical EnumValue -Enum(mips_arch_opt_value) String(r1004kf1_1) Value(73) +Enum(mips_arch_opt_value) String(r1004kf) Value(74) EnumValue -Enum(mips_arch_opt_value) String(5kc) Value(74) Canonical +Enum(mips_arch_opt_value) String(1004kf1_1) Value(75) Canonical EnumValue -Enum(mips_arch_opt_value) String(r5kc) Value(74) +Enum(mips_arch_opt_value) String(r1004kf1_1) Value(75) EnumValue -Enum(mips_arch_opt_value) String(5kf) Value(75) Canonical +Enum(mips_arch_opt_value) String(5kc) Value(76) Canonical EnumValue -Enum(mips_arch_opt_value) String(r5kf) Value(75) +Enum(mips_arch_opt_value) String(r5kc) Value(76) EnumValue -Enum(mips_arch_opt_value) String(20kc) Value(76) Canonical +Enum(mips_arch_opt_value) String(5kf) Value(77) Canonical EnumValue -Enum(mips_arch_opt_value) String(r20kc) Value(76) +Enum(mips_arch_opt_value) String(r5kf) Value(77) EnumValue -Enum(mips_arch_opt_value) String(sb1) Value(77) Canonical +Enum(mips_arch_opt_value) String(20kc) Value(78) Canonical EnumValue -Enum(mips_arch_opt_value) String(sb1a) Value(78) Canonical +Enum(mips_arch_opt_value) String(r20kc) Value(78) EnumValue -Enum(mips_arch_opt_value) String(sr71000) Value(79) Canonical +Enum(mips_arch_opt_value) String(sb1) Value(79) Canonical EnumValue -Enum(mips_arch_opt_value) String(sr71k) Value(79) +Enum(mips_arch_opt_value) String(sb1a) Value(80) Canonical EnumValue -Enum(mips_arch_opt_value) String(xlr) Value(80) Canonical +Enum(mips_arch_opt_value) String(sr71000) Value(81) Canonical EnumValue -Enum(mips_arch_opt_value) String(loongson3a) Value(81) Canonical +Enum(mips_arch_opt_value) String(sr71k) Value(81) EnumValue -Enum(mips_arch_opt_value) String(octeon) Value(82) Canonical +Enum(mips_arch_opt_value) String(xlr) Value(82) Canonical EnumValue -Enum(mips_arch_opt_value) String(octeon+) Value(83) Canonical +Enum(mips_arch_opt_value) String(loongson3a) Value(83) Canonical EnumValue -Enum(mips_arch_opt_value) String(octeon2) Value(84) Canonical +Enum(mips_arch_opt_value) String(octeon) Value(84) Canonical EnumValue -Enum(mips_arch_opt_value) String(xlp) Value(85) Canonical +Enum(mips_arch_opt_value) String(octeon+) Value(85) Canonical + +EnumValue +Enum(mips_arch_opt_value) String(octeon2) Value(86) Canonical + +EnumValue +Enum(mips_arch_opt_value) String(xlp) Value(87) Canonical diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index 53804298f2a..3d356b456ab 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -77,6 +77,9 @@ along with GCC; see the file COPYING3. If not see preserve the maximum stack alignment. We therefore use a value of 0x7ff0 in this case. + microMIPS LWM and SWM support 12-bit offsets (from -0x800 to 0x7ff), + so we use a maximum of 0x7f0 for TARGET_MICROMIPS. + MIPS16e SAVE and RESTORE instructions can adjust the stack pointer by up to 0x7f8 bytes and can usually save or restore all the registers that we need to save or restore. (Note that we can only use these @@ -87,8 +90,8 @@ along with GCC; see the file COPYING3. If not see to save and restore registers, and to allocate and deallocate the top part of the frame. */ #define MIPS_MAX_FIRST_STACK_STEP \ - (!TARGET_MIPS16 ? 0x7ff0 \ - : GENERATE_MIPS16E_SAVE_RESTORE ? 0x7f8 \ + (!TARGET_COMPRESSION ? 0x7ff0 \ + : TARGET_MICROMIPS || GENERATE_MIPS16E_SAVE_RESTORE ? 0x7f8 \ : TARGET_64BIT ? 0x100 : 0x400) /* True if INSN is a mips.md pattern or asm statement. */ @@ -560,8 +563,8 @@ static const struct mips_rtx_cost_data *mips_cost; /* The ambient target flags, excluding MASK_MIPS16. */ static int mips_base_target_flags; -/* True if MIPS16 is the default mode. */ -bool mips_base_mips16; +/* The default compression mode. */ +unsigned int mips_base_compression_flags; /* The ambient values of other global variables. */ static int mips_base_schedule_insns; /* flag_schedule_insns */ @@ -674,6 +677,9 @@ static const struct attribute_spec mips_attribute_table[] = { code generation but don't carry other semantics. */ { "mips16", 0, 0, true, false, false, NULL, false }, { "nomips16", 0, 0, true, false, false, NULL, false }, + { "micromips", 0, 0, true, false, false, NULL, false }, + { "nomicromips", 0, 0, true, false, false, NULL, false }, + { "nocompression", 0, 0, true, false, false, NULL, false }, /* Allow functions to be specified as interrupt handlers */ { "interrupt", 0, 0, false, true, true, NULL, false }, { "use_shadow_register_set", 0, 0, false, true, true, NULL, false }, @@ -1167,10 +1173,11 @@ mflip_mips16_use_mips16_p (tree decl) const char *name; hashval_t hash; void **slot; + bool base_is_mips16 = (mips_base_compression_flags & MASK_MIPS16) != 0; /* Use the opposite of the command-line setting for anonymous decls. */ if (!DECL_NAME (decl)) - return !mips_base_mips16; + return !base_is_mips16; if (!mflip_mips16_htab) mflip_mips16_htab = htab_create_ggc (37, mflip_mips16_htab_hash, @@ -1185,7 +1192,7 @@ mflip_mips16_use_mips16_p (tree decl) mips16_flipper = !mips16_flipper; entry = ggc_alloc_mflip_mips16_entry (); entry->name = name; - entry->mips16_p = mips16_flipper ? !mips_base_mips16 : mips_base_mips16; + entry->mips16_p = mips16_flipper ? !base_is_mips16 : base_is_mips16; *slot = entry; } return entry->mips16_p; @@ -1207,19 +1214,6 @@ mips_far_type_p (const_tree type) || lookup_attribute ("far", TYPE_ATTRIBUTES (type)) != NULL); } -/* Similar predicates for "mips16"/"nomips16" function attributes. */ - -static bool -mips_mips16_decl_p (const_tree decl) -{ - return lookup_attribute ("mips16", DECL_ATTRIBUTES (decl)) != NULL; -} - -static bool -mips_nomips16_decl_p (const_tree decl) -{ - return lookup_attribute ("nomips16", DECL_ATTRIBUTES (decl)) != NULL; -} /* Check if the interrupt attribute is set for a function. */ @@ -1257,12 +1251,52 @@ mips_use_debug_exception_return_p (tree type) TYPE_ATTRIBUTES (type)) != NULL; } -/* Return true if function DECL is a MIPS16 function. Return the ambient - setting if DECL is null. */ +/* Return the set of compression modes that are explicitly required + by the attributes in ATTRIBUTES. */ -static bool -mips_use_mips16_mode_p (tree decl) +static unsigned int +mips_get_compress_on_flags (tree attributes) +{ + unsigned int flags = 0; + + if (lookup_attribute ("mips16", attributes) != NULL) + flags |= MASK_MIPS16; + + if (lookup_attribute ("micromips", attributes) != NULL) + flags |= MASK_MICROMIPS; + + return flags; +} + +/* Return the set of compression modes that are explicitly forbidden + by the attributes in ATTRIBUTES. */ + +static unsigned int +mips_get_compress_off_flags (tree attributes) +{ + unsigned int flags = 0; + + if (lookup_attribute ("nocompression", attributes) != NULL) + flags |= MASK_MIPS16 | MASK_MICROMIPS; + + if (lookup_attribute ("nomips16", attributes) != NULL) + flags |= MASK_MIPS16; + + if (lookup_attribute ("nomicromips", attributes) != NULL) + flags |= MASK_MICROMIPS; + + return flags; +} + +/* Return the compression mode that should be used for function DECL. + Return the ambient setting if DECL is null. */ + +static unsigned int +mips_get_compress_mode (tree decl) { + unsigned int flags, force_on; + + flags = mips_base_compression_flags; if (decl) { /* Nested functions must use the same frame pointer as their @@ -1270,12 +1304,36 @@ mips_use_mips16_mode_p (tree decl) tree parent = decl_function_context (decl); if (parent) decl = parent; - if (mips_mips16_decl_p (decl)) - return true; - if (mips_nomips16_decl_p (decl)) - return false; + force_on = mips_get_compress_on_flags (DECL_ATTRIBUTES (decl)); + if (force_on) + return force_on; + flags &= ~mips_get_compress_off_flags (DECL_ATTRIBUTES (decl)); } - return mips_base_mips16; + return flags; +} + +/* Return the attribute name associated with MASK_MIPS16 and MASK_MICROMIPS + flags FLAGS. */ + +static const char * +mips_get_compress_on_name (unsigned int flags) +{ + if (flags == MASK_MIPS16) + return "mips16"; + return "micromips"; +} + +/* Return the attribute name that forbids MASK_MIPS16 and MASK_MICROMIPS + flags FLAGS. */ + +static const char * +mips_get_compress_off_name (unsigned int flags) +{ + if (flags == MASK_MIPS16) + return "nomips16"; + if (flags == MASK_MICROMIPS) + return "nomicromips"; + return "nocompression"; } /* Implement TARGET_COMP_TYPE_ATTRIBUTES. */ @@ -1297,37 +1355,50 @@ static void mips_insert_attributes (tree decl, tree *attributes) { const char *name; - bool mips16_p, nomips16_p; + unsigned int compression_flags, nocompression_flags; /* Check for "mips16" and "nomips16" attributes. */ - mips16_p = lookup_attribute ("mips16", *attributes) != NULL; - nomips16_p = lookup_attribute ("nomips16", *attributes) != NULL; + compression_flags = mips_get_compress_on_flags (*attributes); + nocompression_flags = mips_get_compress_off_flags (*attributes); + if (TREE_CODE (decl) != FUNCTION_DECL) { - if (mips16_p) - error ("%qs attribute only applies to functions", "mips16"); - if (nomips16_p) - error ("%qs attribute only applies to functions", "nomips16"); + if (nocompression_flags) + error ("%qs attribute only applies to functions", + mips_get_compress_off_name (nocompression_flags)); + + if (compression_flags) + error ("%qs attribute only applies to functions", + mips_get_compress_on_name (nocompression_flags)); } else { - mips16_p |= mips_mips16_decl_p (decl); - nomips16_p |= mips_nomips16_decl_p (decl); - if (mips16_p || nomips16_p) - { - /* DECL cannot be simultaneously "mips16" and "nomips16". */ - if (mips16_p && nomips16_p) - error ("%qE cannot have both %<mips16%> and " - "%<nomips16%> attributes", - DECL_NAME (decl)); - } - else if (TARGET_FLIP_MIPS16 && !DECL_ARTIFICIAL (decl)) + compression_flags |= mips_get_compress_on_flags (DECL_ATTRIBUTES (decl)); + nocompression_flags |= + mips_get_compress_off_flags (DECL_ATTRIBUTES (decl)); + + if (compression_flags && nocompression_flags) + error ("%qE cannot have both %qs and %qs attributes", + DECL_NAME (decl), mips_get_compress_on_name (compression_flags), + mips_get_compress_off_name (nocompression_flags)); + + if (compression_flags & MASK_MIPS16 + && compression_flags & MASK_MICROMIPS) + error ("%qE cannot have both %qs and %qs attributes", + DECL_NAME (decl), "mips16", "micromips"); + + if (TARGET_FLIP_MIPS16 + && !DECL_ARTIFICIAL (decl) + && compression_flags == 0 + && nocompression_flags == 0) { /* Implement -mflip-mips16. If DECL has neither a "nomips16" nor a "mips16" attribute, arbitrarily pick one. We must pick the same setting for duplicate declarations of a function. */ name = mflip_mips16_use_mips16_p (decl) ? "mips16" : "nomips16"; *attributes = tree_cons (get_identifier (name), NULL, *attributes); + name = "nomicromips"; + *attributes = tree_cons (get_identifier (name), NULL, *attributes); } } } @@ -1337,13 +1408,19 @@ mips_insert_attributes (tree decl, tree *attributes) static tree mips_merge_decl_attributes (tree olddecl, tree newdecl) { - /* The decls' "mips16" and "nomips16" attributes must match exactly. */ - if (mips_mips16_decl_p (olddecl) != mips_mips16_decl_p (newdecl)) + unsigned int diff; + + diff = (mips_get_compress_on_flags (DECL_ATTRIBUTES (olddecl)) + ^ mips_get_compress_on_flags (DECL_ATTRIBUTES (newdecl))); + if (diff) error ("%qE redeclared with conflicting %qs attributes", - DECL_NAME (newdecl), "mips16"); - if (mips_nomips16_decl_p (olddecl) != mips_nomips16_decl_p (newdecl)) + DECL_NAME (newdecl), mips_get_compress_on_name (diff)); + + diff = (mips_get_compress_off_flags (DECL_ATTRIBUTES (olddecl)) + ^ mips_get_compress_off_flags (DECL_ATTRIBUTES (newdecl))); + if (diff) error ("%qE redeclared with conflicting %qs attributes", - DECL_NAME (newdecl), "nomips16"); + DECL_NAME (newdecl), mips_get_compress_off_name (diff)); return merge_attributes (DECL_ATTRIBUTES (olddecl), DECL_ATTRIBUTES (newdecl)); @@ -1550,7 +1627,7 @@ mips16_local_function_p (const_rtx x) return (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (x) && !SYMBOL_REF_EXTERNAL_P (x) - && mips_use_mips16_mode_p (SYMBOL_REF_DECL (x))); + && (mips_get_compress_mode (SYMBOL_REF_DECL (x)) & MASK_MIPS16)); } /* Return true if SYMBOL_REF X binds locally. */ @@ -2300,6 +2377,69 @@ mips_address_insns (rtx x, enum machine_mode mode, bool might_split_p) return 0; } +/* Return true if X fits within an unsigned field of BITS bits that is + shifted left SHIFT bits before being used. */ + +bool +mips_unsigned_immediate_p (unsigned HOST_WIDE_INT x, int bits, int shift = 0) +{ + return (x & ((1 << shift) - 1)) == 0 && x < ((unsigned) 1 << (shift + bits)); +} + +/* Return true if X fits within a signed field of BITS bits that is + shifted left SHIFT bits before being used. */ + +bool +mips_signed_immediate_p (unsigned HOST_WIDE_INT x, int bits, int shift = 0) +{ + x += 1 << (bits + shift - 1); + return mips_unsigned_immediate_p (x, bits, shift); +} + +/* Return true if X is legitimate for accessing values of mode MODE, + if it is based on a MIPS16 register, and if the offset satisfies + OFFSET_PREDICATE. */ + +bool +m16_based_address_p (rtx x, enum machine_mode mode, + insn_operand_predicate_fn offset_predicate) +{ + struct mips_address_info addr; + + return (mips_classify_address (&addr, x, mode, false) + && addr.type == ADDRESS_REG + && M16_REG_P (REGNO (addr.reg)) + && offset_predicate (addr.offset, mode)); +} + +/* Return true if X is a legitimate address that conforms to the requirements + for a microMIPS LWSP or SWSP insn. */ + +bool +lwsp_swsp_address_p (rtx x, enum machine_mode mode) +{ + struct mips_address_info addr; + + return (mips_classify_address (&addr, x, mode, false) + && addr.type == ADDRESS_REG + && REGNO (addr.reg) == STACK_POINTER_REGNUM + && uw5_operand (addr.offset, mode)); +} + +/* Return true if X is a legitimate address with a 12-bit offset. + MODE is the mode of the value being accessed. */ + +bool +umips_12bit_offset_address_p (rtx x, enum machine_mode mode) +{ + struct mips_address_info addr; + + return (mips_classify_address (&addr, x, mode, false) + && addr.type == ADDRESS_REG + && CONST_INT_P (addr.offset) + && UMIPS_12BIT_OFFSET_P (INTVAL (addr.offset))); +} + /* Return the number of instructions needed to load constant X. Return 0 if X isn't a valid constant. */ @@ -6097,6 +6237,13 @@ mips_start_function_definition (const char *name, bool mips16_p) else fprintf (asm_out_file, "\t.set\tnomips16\n"); + if (TARGET_MICROMIPS) + fprintf (asm_out_file, "\t.set\tmicromips\n"); +#ifdef HAVE_GAS_MICROMIPS + else + fprintf (asm_out_file, "\t.set\tnomicromips\n"); +#endif + if (!flag_inhibit_size_directive) { fputs ("\t.ent\t", asm_out_file); @@ -6903,6 +7050,37 @@ mips_split_call (rtx insn, rtx call_pattern) mips_restore_gp_from_cprestore_slot (gen_rtx_REG (Pmode, GP_ARG_FIRST + 2)); } +/* Return true if a call to DECL may need to use JALX. */ + +static bool +mips_call_may_need_jalx_p (tree decl) +{ + /* If the current translation unit would use a different mode for DECL, + assume that the call needs JALX. */ + if (mips_get_compress_mode (decl) != TARGET_COMPRESSION) + return true; + + /* mips_get_compress_mode is always accurate for locally-binding + functions in the current translation unit. */ + if (!DECL_EXTERNAL (decl) && targetm.binds_local_p (decl)) + return false; + + /* When -minterlink-compressed is in effect, assume that functions + could use a different encoding mode unless an attribute explicitly + tells us otherwise. */ + if (TARGET_INTERLINK_COMPRESSED) + { + if (!TARGET_COMPRESSION + && mips_get_compress_off_flags (DECL_ATTRIBUTES (decl)) ==0) + return true; + if (TARGET_COMPRESSION + && mips_get_compress_on_flags (DECL_ATTRIBUTES (decl)) == 0) + return true; + } + + return false; +} + /* Implement TARGET_FUNCTION_OK_FOR_SIBCALL. */ static bool @@ -6916,23 +7094,11 @@ mips_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED) if (mips_interrupt_type_p (TREE_TYPE (current_function_decl))) return false; - /* We can't do a sibcall if the called function is a MIPS16 function - because there is no direct "jx" instruction equivalent to "jalx" to - switch the ISA mode. We only care about cases where the sibling - and normal calls would both be direct. */ + /* Direct Js are only possible to functions that use the same ISA encoding. + There is no JX counterpoart of JALX. */ if (decl - && mips_use_mips16_mode_p (decl) - && const_call_insn_operand (XEXP (DECL_RTL (decl), 0), VOIDmode)) - return false; - - /* When -minterlink-mips16 is in effect, assume that non-locally-binding - functions could be MIPS16 ones unless an attribute explicitly tells - us otherwise. */ - if (TARGET_INTERLINK_MIPS16 - && decl - && (DECL_EXTERNAL (decl) || !targetm.binds_local_p (decl)) - && !mips_nomips16_decl_p (decl) - && const_call_insn_operand (XEXP (DECL_RTL (decl), 0), VOIDmode)) + && const_call_insn_operand (XEXP (DECL_RTL (decl), 0), VOIDmode) + && mips_call_may_need_jalx_p (decl)) return false; /* Otherwise OK. */ @@ -7798,6 +7964,9 @@ mips_pop_asm_switch (struct mips_asm_switch *asm_switch) '^' Print the name of the pic call-through register (t9 or $25). '+' Print the name of the gp register (usually gp or $28). '$' Print the name of the stack pointer register (sp or $29). + ':' Print "c" to use the compact version if the delay slot is a nop. + '!' Print "s" to use the short version if the delay slot contains a + 16-bit instruction. See also mips_init_print_operand_pucnt. */ @@ -7881,6 +8050,21 @@ mips_print_operand_punctuation (FILE *file, int ch) fputs (reg_names[STACK_POINTER_REGNUM], file); break; + case ':': + /* When final_sequence is 0, the delay slot will be a nop. We can + use the compact version for microMIPS. */ + if (final_sequence == 0) + putc ('c', file); + break; + + case '!': + /* If the delay slot instruction is short, then use the + compact version. */ + if (final_sequence == 0 + || get_attr_length (XVECEXP (final_sequence, 0, 1)) == 2) + putc ('s', file); + break; + default: gcc_unreachable (); break; @@ -7894,7 +8078,7 @@ mips_init_print_operand_punct (void) { const char *p; - for (p = "()[]<>*#/?~.@^+$"; *p; p++) + for (p = "()[]<>*#/?~.@^+$:!"; *p; p++) mips_print_operand_punct[(unsigned char) *p] = true; } @@ -10236,6 +10420,126 @@ mips_for_each_saved_acc (HOST_WIDE_INT sp_offset, mips_save_restore_fn fn) } } +/* Save register REG to MEM. Make the instruction frame-related. */ + +static void +mips_save_reg (rtx reg, rtx mem) +{ + if (GET_MODE (reg) == DFmode && !TARGET_FLOAT64) + { + rtx x1, x2; + + mips_emit_move_or_split (mem, reg, SPLIT_IF_NECESSARY); + + x1 = mips_frame_set (mips_subword (mem, false), + mips_subword (reg, false)); + x2 = mips_frame_set (mips_subword (mem, true), + mips_subword (reg, true)); + mips_set_frame_expr (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, x1, x2))); + } + else + mips_emit_save_slot_move (mem, reg, MIPS_PROLOGUE_TEMP (GET_MODE (reg))); +} + +/* Capture the register combinations that are allowed in a SWM or LWM + instruction. The entries are ordered by number of registers set in + the mask. We also ignore the single register encodings because a + normal SW/LW is preferred. */ + +static const unsigned int umips_swm_mask[17] = { + 0xc0ff0000, 0x80ff0000, 0x40ff0000, 0x807f0000, + 0x00ff0000, 0x803f0000, 0x007f0000, 0x801f0000, + 0x003f0000, 0x800f0000, 0x001f0000, 0x80070000, + 0x000f0000, 0x80030000, 0x00070000, 0x80010000, + 0x00030000 +}; + +static const unsigned int umips_swm_encoding[17] = { + 25, 24, 9, 23, 8, 22, 7, 21, 6, 20, 5, 19, 4, 18, 3, 17, 2 +}; + +/* Try to use a microMIPS LWM or SWM instruction to save or restore + as many GPRs in *MASK as possible. *OFFSET is the offset from the + stack pointer of the topmost save slot. + + Remove from *MASK all registers that were handled using LWM and SWM. + Update *OFFSET so that it points to the first unused save slot. */ + +static bool +umips_build_save_restore (mips_save_restore_fn fn, + unsigned *mask, HOST_WIDE_INT *offset) +{ + int nregs; + unsigned int i, j; + rtx pattern, set, reg, mem; + HOST_WIDE_INT this_offset; + rtx this_base; + + /* Try matching $16 to $31 (s0 to ra). */ + for (i = 0; i < ARRAY_SIZE (umips_swm_mask); i++) + if ((*mask & 0xffff0000) == umips_swm_mask[i]) + break; + + if (i == ARRAY_SIZE (umips_swm_mask)) + return false; + + /* Get the offset of the lowest save slot. */ + nregs = (umips_swm_encoding[i] & 0xf) + (umips_swm_encoding[i] >> 4); + this_offset = *offset - UNITS_PER_WORD * (nregs - 1); + + /* LWM/SWM can only support offsets from -2048 to 2047. */ + if (!UMIPS_12BIT_OFFSET_P (this_offset)) + return false; + + /* Create the final PARALLEL. */ + pattern = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs)); + this_base = stack_pointer_rtx; + + /* For registers $16-$23 and $30. */ + for (j = 0; j < (umips_swm_encoding[i] & 0xf); j++) + { + HOST_WIDE_INT offset = this_offset + j * UNITS_PER_WORD; + mem = gen_frame_mem (SImode, plus_constant (Pmode, this_base, offset)); + unsigned int regno = (j != 8) ? 16 + j : 30; + *mask &= ~(1 << regno); + reg = gen_rtx_REG (SImode, regno); + if (fn == mips_save_reg) + set = mips_frame_set (mem, reg); + else + { + set = gen_rtx_SET (VOIDmode, reg, mem); + mips_add_cfa_restore (reg); + } + XVECEXP (pattern, 0, j) = set; + } + + /* For register $31. */ + if (umips_swm_encoding[i] >> 4) + { + HOST_WIDE_INT offset = this_offset + j * UNITS_PER_WORD; + *mask &= ~(1 << 31); + mem = gen_frame_mem (SImode, plus_constant (Pmode, this_base, offset)); + reg = gen_rtx_REG (SImode, 31); + if (fn == mips_save_reg) + set = mips_frame_set (mem, reg); + else + { + set = gen_rtx_SET (VOIDmode, reg, mem); + mips_add_cfa_restore (reg); + } + XVECEXP (pattern, 0, j) = set; + } + + pattern = emit_insn (pattern); + if (fn == mips_save_reg) + RTX_FRAME_RELATED_P (pattern) = 1; + + /* Adjust the last offset. */ + *offset -= UNITS_PER_WORD * nregs; + + return true; +} + /* Call FN for each register that is saved by the current function. SP_OFFSET is the offset of the current stack pointer from the start of the frame. */ @@ -10245,16 +10549,23 @@ mips_for_each_saved_gpr_and_fpr (HOST_WIDE_INT sp_offset, mips_save_restore_fn fn) { enum machine_mode fpr_mode; - HOST_WIDE_INT offset; int regno; + const struct mips_frame_info *frame = &cfun->machine->frame; + HOST_WIDE_INT offset; + unsigned int mask; /* Save registers starting from high to low. The debuggers prefer at least the return register be stored at func+4, and also it allows us not to need a nop in the epilogue if at least one register is reloaded in addition to return address. */ - offset = cfun->machine->frame.gp_sp_offset - sp_offset; + offset = frame->gp_sp_offset - sp_offset; + mask = frame->mask; + + if (TARGET_MICROMIPS) + umips_build_save_restore (fn, &mask, &offset); + for (regno = GP_REG_LAST; regno >= GP_REG_FIRST; regno--) - if (BITSET_P (cfun->machine->frame.mask, regno - GP_REG_FIRST)) + if (BITSET_P (mask, regno - GP_REG_FIRST)) { /* Record the ra offset for use by mips_function_profiler. */ if (regno == RETURN_ADDR_REGNUM) @@ -10501,26 +10812,6 @@ mips_frame_barrier (void) emit_clobber (gen_frame_mem (BLKmode, stack_pointer_rtx)); } -/* Save register REG to MEM. Make the instruction frame-related. */ - -static void -mips_save_reg (rtx reg, rtx mem) -{ - if (GET_MODE (reg) == DFmode && !TARGET_FLOAT64) - { - rtx x1, x2; - - mips_emit_move_or_split (mem, reg, SPLIT_IF_NECESSARY); - - x1 = mips_frame_set (mips_subword (mem, false), - mips_subword (reg, false)); - x2 = mips_frame_set (mips_subword (mem, true), - mips_subword (reg, true)); - mips_set_frame_expr (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, x1, x2))); - } - else - mips_emit_save_slot_move (mem, reg, MIPS_PROLOGUE_TEMP (GET_MODE (reg))); -} /* The __gnu_local_gp symbol. */ @@ -11239,7 +11530,7 @@ mips_expand_epilogue (bool sibcall_p) mips_emit_move (gen_rtx_REG (word_mode, K0_REG_NUM), mem); offset -= UNITS_PER_WORD; - /* If we don't use shoadow register set, we need to update SP. */ + /* If we don't use shadow register set, we need to update SP. */ if (!cfun->machine->use_shadow_register_set_p) mips_deallocate_stack (stack_pointer_rtx, GEN_INT (step2), 0); else @@ -11254,6 +11545,7 @@ mips_expand_epilogue (bool sibcall_p) /* Deallocate the final bit of the frame. */ mips_deallocate_stack (stack_pointer_rtx, GEN_INT (step2), 0); } + gcc_assert (!mips_epilogue.cfa_restores); /* Add in the __builtin_eh_return stack adjustment. We need to @@ -16224,17 +16516,19 @@ mips_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, reload_completed = 0; } -/* The last argument passed to mips_set_mips16_mode, or negative if the - function hasn't been called yet. */ -static int was_mips16_p = -1; -/* Set up the target-dependent global state so that it matches the - current function's ISA mode. */ +/* The last argument passed to mips_set_compression_mode, + or negative if the function hasn't been called yet. */ +static unsigned int old_compression_mode = -1; + +/* Set up the target-dependent global state for ISA mode COMPRESSION_MODE, + which is either MASK_MIPS16 or MASK_MICROMIPS. */ static void -mips_set_mips16_mode (int mips16_p) +mips_set_compression_mode (unsigned int compression_mode) { - if (mips16_p == was_mips16_p) + + if (compression_mode == old_compression_mode) return; /* Restore base settings of various flags. */ @@ -16245,8 +16539,10 @@ mips_set_mips16_mode (int mips16_p) align_loops = mips_base_align_loops; align_jumps = mips_base_align_jumps; align_functions = mips_base_align_functions; + target_flags &= ~(MASK_MIPS16 | MASK_MICROMIPS); + target_flags |= compression_mode; - if (mips16_p) + if (compression_mode & MASK_MIPS16) { /* Switch to MIPS16 mode. */ target_flags |= MASK_MIPS16; @@ -16300,8 +16596,11 @@ mips_set_mips16_mode (int mips16_p) } else { - /* Switch to normal (non-MIPS16) mode. */ - target_flags &= ~MASK_MIPS16; + /* Switch to microMIPS or the standard encoding. */ + + if (TARGET_MICROMIPS) + /* Avoid branch likely. */ + target_flags &= ~MASK_BRANCHLIKELY; /* Provide default values for align_* for 64-bit targets. */ if (TARGET_64BIT) @@ -16323,7 +16622,7 @@ mips_set_mips16_mode (int mips16_p) /* (Re)initialize MIPS target internals for new ISA. */ mips_init_relocs (); - if (mips16_p) + if (compression_mode & MASK_MIPS16) { if (!mips16_globals) mips16_globals = save_target_globals_default_opts (); @@ -16333,16 +16632,17 @@ mips_set_mips16_mode (int mips16_p) else restore_target_globals (&default_target_globals); - was_mips16_p = mips16_p; + old_compression_mode = compression_mode; } /* Implement TARGET_SET_CURRENT_FUNCTION. Decide whether the current - function should use the MIPS16 ISA and switch modes accordingly. */ + function should use the MIPS16 or microMIPS ISA and switch modes + accordingly. */ static void mips_set_current_function (tree fndecl) { - mips_set_mips16_mode (mips_use_mips16_mode_p (fndecl)); + mips_set_compression_mode (mips_get_compress_mode (fndecl)); } /* Allocate a chunk of memory for per-function machine-dependent data. */ @@ -16450,14 +16750,19 @@ mips_option_override (void) if (global_options_set.x_mips_isa_option) mips_isa_option_info = &mips_cpu_info_table[mips_isa_option]; - /* Process flags as though we were generating non-MIPS16 code. */ - mips_base_mips16 = TARGET_MIPS16; - target_flags &= ~MASK_MIPS16; - #ifdef SUBTARGET_OVERRIDE_OPTIONS SUBTARGET_OVERRIDE_OPTIONS; #endif + /* MIPS16 and microMIPS cannot coexist. */ + if (TARGET_MICROMIPS && TARGET_MIPS16) + error ("unsupported combination: %s", "-mips16 -mmicromips"); + + /* Save the base compression state and process flags as though we + were generating uncompressed code. */ + mips_base_compression_flags = TARGET_COMPRESSION; + target_flags &= ~TARGET_COMPRESSION; + /* -mno-float overrides -mhard-float and -msoft-float. */ if (TARGET_NO_FLOAT) { @@ -16466,7 +16771,7 @@ mips_option_override (void) } if (TARGET_FLIP_MIPS16) - TARGET_INTERLINK_MIPS16 = 1; + TARGET_INTERLINK_COMPRESSED = 1; /* Set the small data limit. */ mips_small_data_threshold = (global_options_set.x_g_switch_value @@ -16839,9 +17144,9 @@ mips_option_override (void) /* Now select the ISA mode. - Do all CPP-sensitive stuff in non-MIPS16 mode; we'll switch to - MIPS16 mode afterwards if need be. */ - mips_set_mips16_mode (false); + Do all CPP-sensitive stuff in uncompressed mode; we'll switch modes + later if required. */ + mips_set_compression_mode (0); } /* Swap the register information for registers I and I + 1, which @@ -17101,6 +17406,277 @@ mips_mulsidi3_gen_fn (enum rtx_code ext_code) return signed_p ? gen_mulsidi3_32bit : gen_umulsidi3_32bit; } } + +/* Return true if PATTERN matches the kind of instruction generated by + umips_build_save_restore. SAVE_P is true for store. */ + +bool +umips_save_restore_pattern_p (bool save_p, rtx pattern) +{ + int n; + unsigned int i; + HOST_WIDE_INT first_offset = 0; + rtx first_base = 0; + unsigned int regmask = 0; + + for (n = 0; n < XVECLEN (pattern, 0); n++) + { + rtx set, reg, mem, this_base; + HOST_WIDE_INT this_offset; + + /* Check that we have a SET. */ + set = XVECEXP (pattern, 0, n); + if (GET_CODE (set) != SET) + return false; + + /* Check that the SET is a load (if restoring) or a store + (if saving). */ + mem = save_p ? SET_DEST (set) : SET_SRC (set); + if (!MEM_P (mem) || MEM_VOLATILE_P (mem)) + return false; + + /* Check that the address is the sum of base and a possibly-zero + constant offset. Determine if the offset is in range. */ + mips_split_plus (XEXP (mem, 0), &this_base, &this_offset); + if (!REG_P (this_base)) + return false; + + if (n == 0) + { + if (!UMIPS_12BIT_OFFSET_P (this_offset)) + return false; + first_base = this_base; + first_offset = this_offset; + } + else + { + /* Check that the save slots are consecutive. */ + if (REGNO (this_base) != REGNO (first_base) + || this_offset != first_offset + UNITS_PER_WORD * n) + return false; + } + + /* Check that SET's other operand is a register. */ + reg = save_p ? SET_SRC (set) : SET_DEST (set); + if (!REG_P (reg)) + return false; + + regmask |= 1 << REGNO (reg); + } + + for (i = 0; i < ARRAY_SIZE (umips_swm_mask); i++) + if (regmask == umips_swm_mask[i]) + return true; + + return false; +} + +/* Return the assembly instruction for microMIPS LWM or SWM. + SAVE_P and PATTERN are as for umips_save_restore_pattern_p. */ + +const char * +umips_output_save_restore (bool save_p, rtx pattern) +{ + static char buffer[300]; + char *s; + int n; + HOST_WIDE_INT offset; + rtx base, mem, set, last_set, last_reg; + + /* Parse the pattern. */ + gcc_assert (umips_save_restore_pattern_p (save_p, pattern)); + + s = strcpy (buffer, save_p ? "swm\t" : "lwm\t"); + s += strlen (s); + n = XVECLEN (pattern, 0); + + set = XVECEXP (pattern, 0, 0); + mem = save_p ? SET_DEST (set) : SET_SRC (set); + mips_split_plus (XEXP (mem, 0), &base, &offset); + + last_set = XVECEXP (pattern, 0, n - 1); + last_reg = save_p ? SET_SRC (last_set) : SET_DEST (last_set); + + if (REGNO (last_reg) == 31) + n--; + + gcc_assert (n <= 9); + if (n == 0) + ; + else if (n == 1) + s += sprintf (s, "%s,", reg_names[16]); + else if (n < 9) + s += sprintf (s, "%s-%s,", reg_names[16], reg_names[15 + n]); + else if (n == 9) + s += sprintf (s, "%s-%s,%s,", reg_names[16], reg_names[23], + reg_names[30]); + + if (REGNO (last_reg) == 31) + s += sprintf (s, "%s,", reg_names[31]); + + s += sprintf (s, "%d(%s)", (int)offset, reg_names[REGNO (base)]); + return buffer; +} + +/* Return true if MEM1 and MEM2 use the same base register, and the + offset of MEM2 equals the offset of MEM1 plus 4. FIRST_REG is the + register into (from) which the contents of MEM1 will be loaded + (stored), depending on the value of LOAD_P. + SWAP_P is true when the 1st and 2nd instructions are swapped. */ + +static bool +umips_load_store_pair_p_1 (bool load_p, bool swap_p, + rtx first_reg, rtx mem1, rtx mem2) +{ + rtx base1, base2; + HOST_WIDE_INT offset1, offset2; + + if (!MEM_P (mem1) || !MEM_P (mem2)) + return false; + + mips_split_plus (XEXP (mem1, 0), &base1, &offset1); + mips_split_plus (XEXP (mem2, 0), &base2, &offset2); + + if (!REG_P (base1) || !rtx_equal_p (base1, base2)) + return false; + + /* Avoid invalid load pair instructions. */ + if (load_p && REGNO (first_reg) == REGNO (base1)) + return false; + + /* We must avoid this case for anti-dependence. + Ex: lw $3, 4($3) + lw $2, 0($3) + first_reg is $2, but the base is $3. */ + if (load_p + && swap_p + && REGNO (first_reg) + 1 == REGNO (base1)) + return false; + + if (offset2 != offset1 + 4) + return false; + + if (!UMIPS_12BIT_OFFSET_P (offset1)) + return false; + + return true; +} + +/* OPERANDS describes the operands to a pair of SETs, in the order + dest1, src1, dest2, src2. Return true if the operands can be used + in an LWP or SWP instruction; LOAD_P says which. */ + +bool +umips_load_store_pair_p (bool load_p, rtx *operands) +{ + rtx reg1, reg2, mem1, mem2; + + if (load_p) + { + reg1 = operands[0]; + reg2 = operands[2]; + mem1 = operands[1]; + mem2 = operands[3]; + } + else + { + reg1 = operands[1]; + reg2 = operands[3]; + mem1 = operands[0]; + mem2 = operands[2]; + } + + if (REGNO (reg2) == REGNO (reg1) + 1) + return umips_load_store_pair_p_1 (load_p, false, reg1, mem1, mem2); + + if (REGNO (reg1) == REGNO (reg2) + 1) + return umips_load_store_pair_p_1 (load_p, true, reg2, mem2, mem1); + + return false; +} + +/* Return the assembly instruction for a microMIPS LWP or SWP in which + the first register is REG and the first memory slot is MEM. + LOAD_P is true for LWP. */ + +static void +umips_output_load_store_pair_1 (bool load_p, rtx reg, rtx mem) +{ + rtx ops[] = {reg, mem}; + + if (load_p) + output_asm_insn ("lwp\t%0,%1", ops); + else + output_asm_insn ("swp\t%0,%1", ops); +} + +/* Output the assembly instruction for a microMIPS LWP or SWP instruction. + LOAD_P and OPERANDS are as for umips_load_store_pair_p. */ + +void +umips_output_load_store_pair (bool load_p, rtx *operands) +{ + rtx reg1, reg2, mem1, mem2; + if (load_p) + { + reg1 = operands[0]; + reg2 = operands[2]; + mem1 = operands[1]; + mem2 = operands[3]; + } + else + { + reg1 = operands[1]; + reg2 = operands[3]; + mem1 = operands[0]; + mem2 = operands[2]; + } + + if (REGNO (reg2) == REGNO (reg1) + 1) + { + umips_output_load_store_pair_1 (load_p, reg1, mem1); + return; + } + + gcc_assert (REGNO (reg1) == REGNO (reg2) + 1); + umips_output_load_store_pair_1 (load_p, reg2, mem2); +} + +/* Return true if REG1 and REG2 match the criteria for a movep insn. */ + +bool +umips_movep_target_p (rtx reg1, rtx reg2) +{ + int regno1, regno2, pair; + unsigned int i; + static const int match[8] = { + 0x00000060, /* 5, 6 */ + 0x000000a0, /* 5, 7 */ + 0x000000c0, /* 6, 7 */ + 0x00200010, /* 4, 21 */ + 0x00400010, /* 4, 22 */ + 0x00000030, /* 4, 5 */ + 0x00000050, /* 4, 6 */ + 0x00000090 /* 4, 7 */ + }; + + if (!REG_P (reg1) || !REG_P (reg2)) + return false; + + regno1 = REGNO (reg1); + regno2 = REGNO (reg2); + + if (!GP_REG_P (regno1) || !GP_REG_P (regno2)) + return false; + + pair = (1 << regno1) | (1 << regno2); + + for (i = 0; i < ARRAY_SIZE (match); i++) + if (pair == match[i]) + return true; + + return false; +} /* Return the size in bytes of the trampoline code, padded to TRAMPOLINE_ALIGNMENT bits. The static chain pointer and target @@ -17355,7 +17931,7 @@ mips_prepare_pch_save (void) It therefore seems best to switch back to non-MIPS16 mode at save time, and to ensure that mips16_globals remains null after a PCH load. */ - mips_set_mips16_mode (false); + mips_set_compression_mode (0); mips16_globals = 0; } diff --git a/gcc/config/mips/mips.h b/gcc/config/mips/mips.h index 0acce14bd8c..0db36988dcc 100644 --- a/gcc/config/mips/mips.h +++ b/gcc/config/mips/mips.h @@ -174,6 +174,9 @@ struct mips_cpu_info { #define ISA_HAS_DSP_MULT ISA_HAS_DSPR2 #endif +/* The ISA compression flags that are currently in effect. */ +#define TARGET_COMPRESSION (target_flags & (MASK_MIPS16 | MASK_MICROMIPS)) + /* Generate mips16 code */ #define TARGET_MIPS16 ((target_flags & MASK_MIPS16) != 0) /* Generate mips16e code. Default 16bit ASE for mips32* and mips64* */ @@ -374,7 +377,7 @@ struct mips_cpu_info { else \ builtin_define ("__mips_fpr=32"); \ \ - if (mips_base_mips16) \ + if (mips_base_compression_flags & MASK_MIPS16) \ builtin_define ("__mips16"); \ \ if (TARGET_MIPS3D) \ @@ -383,6 +386,9 @@ struct mips_cpu_info { if (TARGET_SMARTMIPS) \ builtin_define ("__mips_smartmips"); \ \ + if (mips_base_compression_flags & MASK_MICROMIPS) \ + builtin_define ("__mips_micromips"); \ + \ if (TARGET_MCU) \ builtin_define ("__mips_mcu"); \ \ @@ -702,7 +708,7 @@ struct mips_cpu_info { |march=r10000|march=r12000|march=r14000|march=r16000:-mips4} \ %{march=mips32|march=4kc|march=4km|march=4kp|march=4ksc:-mips32} \ %{march=mips32r2|march=m4k|march=4ke*|march=4ksd|march=24k* \ - |march=34k*|march=74k*|march=1004k*: -mips32r2} \ + |march=34k*|march=74k*|march=m14k*|march=1004k*: -mips32r2} \ %{march=mips64|march=5k*|march=20k*|march=sb1*|march=sr71000 \ |march=xlr|march=loongson3a: -mips64} \ %{march=mips64r2|march=octeon|march=xlp: -mips64r2} \ @@ -716,7 +722,7 @@ struct mips_cpu_info { "%{mhard-float|msoft-float|mno-float|march=mips*:; \ march=vr41*|march=m4k|march=4k*|march=24kc|march=24kec \ |march=34kc|march=34kn|march=74kc|march=1004kc|march=5kc \ - |march=octeon|march=xlr: -msoft-float; \ + |march=m14k*|march=octeon|march=xlr: -msoft-float; \ march=*: -mhard-float}" /* A spec condition that matches 32-bit options. It only works if @@ -989,7 +995,8 @@ struct mips_cpu_info { || ISA_MIPS64R2)) /* ISA has lwxs instruction (load w/scaled index address. */ -#define ISA_HAS_LWXS (TARGET_SMARTMIPS && !TARGET_MIPS16) +#define ISA_HAS_LWXS ((TARGET_SMARTMIPS || TARGET_MICROMIPS) \ + && !TARGET_MIPS16) /* ISA has lbx, lbux, lhx, lhx, lhux, lwx, lwux, or ldx instruction. */ #define ISA_HAS_LBX (TARGET_OCTEON2) @@ -1012,7 +1019,8 @@ struct mips_cpu_info { and "addiu $4,$4,1". */ #define ISA_HAS_LOAD_DELAY (ISA_MIPS1 \ && !TARGET_MIPS3900 \ - && !TARGET_MIPS16) + && !TARGET_MIPS16 \ + && !TARGET_MICROMIPS) /* Likewise mtc1 and mfc1. */ #define ISA_HAS_XFER_DELAY (mips_isa <= 3 \ @@ -1123,6 +1131,7 @@ struct mips_cpu_info { %{G*} %(endian_spec) %{mips1} %{mips2} %{mips3} %{mips4} \ %{mips32*} %{mips64*} \ %{mips16} %{mno-mips16:-no-mips16} \ +%{mmicromips} %{mno-micromips} \ %{mips3d} %{mno-mips3d:-no-mips3d} \ %{mdmx} %{mno-mdmx:-no-mdmx} \ %{mdsp} %{mno-dsp} \ @@ -1672,6 +1681,8 @@ struct mips_cpu_info { ((unsigned int) ((int) (REGNO) - GP_REG_FIRST) < GP_REG_NUM) #define M16_REG_P(REGNO) \ (((REGNO) >= 2 && (REGNO) <= 7) || (REGNO) == 16 || (REGNO) == 17) +#define M16STORE_REG_P(REGNO) \ + (((REGNO) >= 2 && (REGNO) <= 7) || (REGNO) == 0 || (REGNO) == 17) #define FP_REG_P(REGNO) \ ((unsigned int) ((int) (REGNO) - FP_REG_FIRST) < FP_REG_NUM) #define MD_REG_P(REGNO) \ @@ -2034,6 +2045,7 @@ enum reg_class #define SMALL_INT(X) SMALL_OPERAND (INTVAL (X)) #define SMALL_INT_UNSIGNED(X) SMALL_OPERAND_UNSIGNED (INTVAL (X)) #define LUI_INT(X) LUI_OPERAND (INTVAL (X)) +#define UMIPS_12BIT_OFFSET_P(OFFSET) (IN_RANGE (OFFSET, -2048, 2047)) /* The HI and LO registers can only be reloaded via the general registers. Condition code registers can only be loaded to the @@ -2452,17 +2464,32 @@ typedef struct mips_args { all calls should use assembly macros. Otherwise, all indirect calls should use "jr" or "jalr"; we will arrange to restore $gp afterwards if necessary. Finally, we can only generate direct - calls for -mabicalls by temporarily switching to non-PIC mode. */ + calls for -mabicalls by temporarily switching to non-PIC mode. + + For microMIPS jal(r), we try to generate jal(r)s when a 16-bit + instruction is in the delay slot of jal(r). */ #define MIPS_CALL(INSN, OPERANDS, TARGET_OPNO, SIZE_OPNO) \ (TARGET_USE_GOT && !TARGET_EXPLICIT_RELOCS \ ? "%*" INSN "\t%" #TARGET_OPNO "%/" \ - : (REG_P (OPERANDS[TARGET_OPNO]) \ - && mips_get_pic_call_symbol (OPERANDS, SIZE_OPNO)) \ - ? ("%*.reloc\t1f,R_MIPS_JALR,%" #SIZE_OPNO "\n" \ - "1:\t" INSN "r\t%" #TARGET_OPNO "%/") \ : REG_P (OPERANDS[TARGET_OPNO]) \ - ? "%*" INSN "r\t%" #TARGET_OPNO "%/" \ + ? (mips_get_pic_call_symbol (OPERANDS, SIZE_OPNO) \ + ? ("%*.reloc\t1f,R_MIPS_JALR,%" #SIZE_OPNO "\n" \ + "1:\t" INSN "r\t%" #TARGET_OPNO "%/") \ + : TARGET_MICROMIPS && !TARGET_INTERLINK_COMPRESSED \ + ? "%*" INSN "r%!\t%" #TARGET_OPNO "%/" \ + : "%*" INSN "r\t%" #TARGET_OPNO "%/") \ : MIPS_ABSOLUTE_JUMP ("%*" INSN "\t%" #TARGET_OPNO "%/")) + +/* Similar to MIPS_CALL, but this is for MICROMIPS "j" to generate + "jrc" when nop is in the delay slot of "jr". */ + +#define MICROMIPS_J(INSN, OPERANDS, OPNO) \ + (TARGET_USE_GOT && !TARGET_EXPLICIT_RELOCS \ + ? "%*j\t%" #OPNO "%/" \ + : REG_P (OPERANDS[OPNO]) \ + ? "%*jr%:\t%" #OPNO \ + : MIPS_ABSOLUTE_JUMP ("%*" INSN "\t%" #OPNO "%/")) + /* Control the assembler format that we output. */ @@ -2877,7 +2904,7 @@ extern enum processor mips_tune; /* which cpu to schedule for */ extern int mips_isa; /* architectural level */ extern const struct mips_cpu_info *mips_arch_info; extern const struct mips_cpu_info *mips_tune_info; -extern bool mips_base_mips16; +extern unsigned int mips_base_compression_flags; extern GTY(()) struct target_globals *mips16_globals; #endif diff --git a/gcc/config/mips/mips.md b/gcc/config/mips/mips.md index 7aa461dbd69..2f629107a57 100644 --- a/gcc/config/mips/mips.md +++ b/gcc/config/mips/mips.md @@ -342,13 +342,14 @@ ;; syncloop memory atomic operation implemented as a sync loop ;; nop no operation ;; ghost an instruction that produces no real code +;; multimem microMIPS multiword load and store (define_attr "type" "unknown,branch,jump,call,load,fpload,fpidxload,store,fpstore,fpidxstore, prefetch,prefetchx,condmove,mtc,mfc,mthi,mtlo,mfhi,mflo,const,arith,logical, shift,slt,signext,clz,pop,trap,imul,imul3,imul3nc,imadd,idiv,idiv3,move, fmove,fadd,fmul,fmadd,fdiv,frdiv,frdiv1,frdiv2,fabs,fneg,fcmp,fcvt,fsqrt, frsqrt,frsqrt1,frsqrt2,dspmac,dspmacsat,accext,accmod,dspalu,dspalusat, - multi,atomic,syncloop,nop,ghost" + multi,atomic,syncloop,nop,ghost,multimem" (cond [(eq_attr "jal" "!unset") (const_string "call") (eq_attr "got" "load") (const_string "load") @@ -411,11 +412,32 @@ (const_string "yes") (const_string "no"))) +(define_attr "compression" "none,all,micromips" + (const_string "none")) + +(define_attr "enabled" "no,yes" + (if_then_else (ior (eq_attr "compression" "all,none") + (and (eq_attr "compression" "micromips") + (match_test "TARGET_MICROMIPS"))) + (const_string "yes") + (const_string "no"))) + ;; Length of instruction in bytes. (define_attr "length" "" - (cond [;; Direct branch instructions have a range of [-0x20000,0x1fffc], - ;; relative to the address of the delay slot. If a branch is - ;; outside this range, we have a choice of two sequences. + (cond [(and (eq_attr "extended_mips16" "yes") + (match_test "TARGET_MIPS16")) + (const_int 8) + + (and (eq_attr "compression" "micromips,all") + (eq_attr "dword_mode" "no") + (match_test "TARGET_MICROMIPS")) + (const_int 2) + + ;; Direct microMIPS branch instructions have a range of + ;; [-0x10000,0xfffe], otherwise the range is [-0x20000,0x1fffc]. + ;; If a branch is outside this range, we have a choice of two + ;; sequences. + ;; ;; For PIC, an out-of-range branch like: ;; ;; bne r1,r2,target @@ -451,8 +473,15 @@ ;; from the shorten_branches reference address. (and (eq_attr "type" "branch") (not (match_test "TARGET_MIPS16"))) - (cond [(and (le (minus (match_dup 0) (pc)) (const_int 131064)) - (le (minus (pc) (match_dup 0)) (const_int 131068))) + (cond [;; Any variant can handle the 17-bit range. + (and (le (minus (match_dup 0) (pc)) (const_int 65532)) + (le (minus (pc) (match_dup 0)) (const_int 65534))) + (const_int 4) + + ;; The 18-bit range is OK other than for microMIPS. + (and (not (match_test "TARGET_MICROMIPS")) + (and (le (minus (match_dup 0) (pc)) (const_int 131064)) + (le (minus (pc) (match_dup 0)) (const_int 131068)))) (const_int 4) ;; The non-PIC case: branch, first delay slot, and J. @@ -712,6 +741,9 @@ ;; modes. (define_mode_iterator GPR2 [SI (DI "TARGET_64BIT")]) +(define_mode_iterator MOVEP1 [SI SF]) +(define_mode_iterator MOVEP2 [SI SF]) + ;; This mode iterator allows :HILO to be used as the mode of the ;; concatenated HI and LO registers. (define_mode_iterator HILO [(DI "!TARGET_64BIT") (TI "TARGET_64BIT")]) @@ -947,6 +979,10 @@ (xor "xori") (and "andi")]) +(define_code_attr shift_compression [(ashift "micromips") + (lshiftrt "micromips") + (ashiftrt "none")]) + ;; <fcond> is the c.cond.fmt condition associated with a particular code. (define_code_attr fcond [(unordered "un") (uneq "ueq") @@ -1114,14 +1150,19 @@ "") (define_insn "*add<mode>3" - [(set (match_operand:GPR 0 "register_operand" "=d,d") - (plus:GPR (match_operand:GPR 1 "register_operand" "d,d") - (match_operand:GPR 2 "arith_operand" "d,Q")))] + [(set (match_operand:GPR 0 "register_operand" "=!u,d,!u,!u,!ks,!d,d") + (plus:GPR (match_operand:GPR 1 "register_operand" "!u,d,!u,!ks,!ks,0,d") + (match_operand:GPR 2 "arith_operand" "!u,d,Uead,Uuw6,Uesp,Usb4,Q")))] "!TARGET_MIPS16" - "@ - <d>addu\t%0,%1,%2 - <d>addiu\t%0,%1,%2" +{ + if (which_alternative == 0 + || which_alternative == 1) + return "<d>addu\t%0,%1,%2"; + else + return "<d>addiu\t%0,%1,%2"; +} [(set_attr "alu_type" "add") + (set_attr "compression" "micromips,*,micromips,micromips,micromips,micromips,*") (set_attr "mode" "<MODE>")]) (define_insn "*add<mode>3_mips16" @@ -1330,12 +1371,13 @@ (set_attr "mode" "<UNITMODE>")]) (define_insn "sub<mode>3" - [(set (match_operand:GPR 0 "register_operand" "=d") - (minus:GPR (match_operand:GPR 1 "register_operand" "d") - (match_operand:GPR 2 "register_operand" "d")))] + [(set (match_operand:GPR 0 "register_operand" "=!u,d") + (minus:GPR (match_operand:GPR 1 "register_operand" "!u,d") + (match_operand:GPR 2 "register_operand" "!u,d")))] "" "<d>subu\t%0,%1,%2" [(set_attr "alu_type" "sub") + (set_attr "compression" "micromips,*") (set_attr "mode" "<MODE>")]) (define_insn "*subsi3_extended" @@ -2811,8 +2853,8 @@ (set_attr "mode" "<UNITMODE>")]) (define_insn "one_cmpl<mode>2" - [(set (match_operand:GPR 0 "register_operand" "=d") - (not:GPR (match_operand:GPR 1 "register_operand" "d")))] + [(set (match_operand:GPR 0 "register_operand" "=!u,d") + (not:GPR (match_operand:GPR 1 "register_operand" "!u,d")))] "" { if (TARGET_MIPS16) @@ -2821,6 +2863,7 @@ return "nor\t%0,%.,%1"; } [(set_attr "alu_type" "not") + (set_attr "compression" "micromips,*") (set_attr "mode" "<MODE>")]) ;; @@ -2861,9 +2904,9 @@ ;; register =op1 x (define_insn "*and<mode>3" - [(set (match_operand:GPR 0 "register_operand" "=d,d,d,d,d,d,d") - (and:GPR (match_operand:GPR 1 "nonimmediate_operand" "o,o,W,d,d,d,d") - (match_operand:GPR 2 "and_operand" "Yb,Yh,Yw,K,Yx,Yw,d")))] + [(set (match_operand:GPR 0 "register_operand" "=d,d,d,!u,d,d,d,!u,d") + (and:GPR (match_operand:GPR 1 "nonimmediate_operand" "o,o,W,!u,d,d,d,0,d") + (match_operand:GPR 2 "and_operand" "Yb,Yh,Yw,Uean,K,Yx,Yw,!u,d")))] "!TARGET_MIPS16 && and_operands_ok (<MODE>mode, operands[1], operands[2])" { int len; @@ -2880,20 +2923,23 @@ operands[1] = gen_lowpart (SImode, operands[1]); return "lwu\t%0,%1"; case 3: - return "andi\t%0,%1,%x2"; case 4: + return "andi\t%0,%1,%x2"; + case 5: len = low_bitmask_len (<MODE>mode, INTVAL (operands[2])); operands[2] = GEN_INT (len); return "<d>ext\t%0,%1,0,%2"; - case 5: - return "#"; case 6: + return "#"; + case 7: + case 8: return "and\t%0,%1,%2"; default: gcc_unreachable (); } } - [(set_attr "move_type" "load,load,load,andi,ext_ins,shift_shift,logical") + [(set_attr "move_type" "load,load,load,andi,andi,ext_ins,shift_shift,logical,logical") + (set_attr "compression" "*,*,*,micromips,*,*,*,micromips,*") (set_attr "mode" "<MODE>")]) (define_insn "*and<mode>3_mips16" @@ -2935,14 +2981,16 @@ }) (define_insn "*ior<mode>3" - [(set (match_operand:GPR 0 "register_operand" "=d,d") - (ior:GPR (match_operand:GPR 1 "register_operand" "%d,d") - (match_operand:GPR 2 "uns_arith_operand" "d,K")))] + [(set (match_operand:GPR 0 "register_operand" "=!u,d,d") + (ior:GPR (match_operand:GPR 1 "register_operand" "%0,d,d") + (match_operand:GPR 2 "uns_arith_operand" "!u,d,K")))] "!TARGET_MIPS16" "@ or\t%0,%1,%2 + or\t%0,%1,%2 ori\t%0,%1,%x2" [(set_attr "alu_type" "or") + (set_attr "compression" "micromips,*,*") (set_attr "mode" "<MODE>")]) (define_insn "*ior<mode>3_mips16" @@ -2962,14 +3010,16 @@ "") (define_insn "" - [(set (match_operand:GPR 0 "register_operand" "=d,d") - (xor:GPR (match_operand:GPR 1 "register_operand" "%d,d") - (match_operand:GPR 2 "uns_arith_operand" "d,K")))] + [(set (match_operand:GPR 0 "register_operand" "=!u,d,d") + (xor:GPR (match_operand:GPR 1 "register_operand" "%0,d,d") + (match_operand:GPR 2 "uns_arith_operand" "!u,d,K")))] "!TARGET_MIPS16" "@ xor\t%0,%1,%2 + xor\t%0,%1,%2 xori\t%0,%1,%x2" [(set_attr "alu_type" "xor") + (set_attr "compression" "micromips,*,*") (set_attr "mode" "<MODE>")]) (define_insn "" @@ -3145,14 +3195,16 @@ }) (define_insn "*zero_extend<SHORT:mode><GPR:mode>2" - [(set (match_operand:GPR 0 "register_operand" "=d,d") + [(set (match_operand:GPR 0 "register_operand" "=!u,d,d") (zero_extend:GPR - (match_operand:SHORT 1 "nonimmediate_operand" "d,m")))] + (match_operand:SHORT 1 "nonimmediate_operand" "!u,d,m")))] "!TARGET_MIPS16" "@ andi\t%0,%1,<SHORT:mask> + andi\t%0,%1,<SHORT:mask> l<SHORT:size>u\t%0,%1" - [(set_attr "move_type" "andi,load") + [(set_attr "move_type" "andi,andi,load") + (set_attr "compression" "micromips,*,*") (set_attr "mode" "<GPR:MODE>")]) (define_insn "*zero_extend<SHORT:mode><GPR:mode>2_mips16e" @@ -3937,7 +3989,7 @@ (define_insn "mov_<load>l" [(set (match_operand:GPR 0 "register_operand" "=d") (unspec:GPR [(match_operand:BLK 1 "memory_operand" "m") - (match_operand:QI 2 "memory_operand" "m")] + (match_operand:QI 2 "memory_operand" "ZC")] UNSPEC_LOAD_LEFT))] "!TARGET_MIPS16 && mips_mem_fits_mode_p (<MODE>mode, operands[1])" "<load>l\t%0,%2" @@ -3947,7 +3999,7 @@ (define_insn "mov_<load>r" [(set (match_operand:GPR 0 "register_operand" "=d") (unspec:GPR [(match_operand:BLK 1 "memory_operand" "m") - (match_operand:QI 2 "memory_operand" "m") + (match_operand:QI 2 "memory_operand" "ZC") (match_operand:GPR 3 "register_operand" "0")] UNSPEC_LOAD_RIGHT))] "!TARGET_MIPS16 && mips_mem_fits_mode_p (<MODE>mode, operands[1])" @@ -3958,7 +4010,7 @@ (define_insn "mov_<store>l" [(set (match_operand:BLK 0 "memory_operand" "=m") (unspec:BLK [(match_operand:GPR 1 "reg_or_0_operand" "dJ") - (match_operand:QI 2 "memory_operand" "m")] + (match_operand:QI 2 "memory_operand" "ZC")] UNSPEC_STORE_LEFT))] "!TARGET_MIPS16 && mips_mem_fits_mode_p (<MODE>mode, operands[0])" "<store>l\t%z1,%2" @@ -3968,7 +4020,7 @@ (define_insn "mov_<store>r" [(set (match_operand:BLK 0 "memory_operand" "+m") (unspec:BLK [(match_operand:GPR 1 "reg_or_0_operand" "dJ") - (match_operand:QI 2 "memory_operand" "m") + (match_operand:QI 2 "memory_operand" "ZC") (match_dup 0)] UNSPEC_STORE_RIGHT))] "!TARGET_MIPS16 && mips_mem_fits_mode_p (<MODE>mode, operands[0])" @@ -4268,7 +4320,7 @@ (define_insn "*movdi_64bit" [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,e,d,m,*f,*f,*d,*m,*a,*d,*B*C*D,*B*C*D,*d,*m") - (match_operand:DI 1 "move_operand" "d,U,T,m,dJ,*d*J,*m,*f,*f,*J*d,*a,*d,*m,*B*C*D,*B*C*D"))] + (match_operand:DI 1 "move_operand" "d,Yd,Yf,m,dJ,*d*J,*m,*f,*f,*J*d,*a,*d,*m,*B*C*D,*B*C*D"))] "TARGET_64BIT && !TARGET_MIPS16 && (register_operand (operands[0], DImode) || reg_or_0_operand (operands[1], DImode))" @@ -4278,7 +4330,7 @@ (define_insn "*movdi_64bit_mips16" [(set (match_operand:DI 0 "nonimmediate_operand" "=d,y,d,d,d,d,d,d,m,*d") - (match_operand:DI 1 "move_operand" "d,d,y,K,N,U,kf,m,d,*a"))] + (match_operand:DI 1 "move_operand" "d,d,y,K,N,Yd,kf,m,d,*a"))] "TARGET_64BIT && TARGET_MIPS16 && (register_operand (operands[0], DImode) || register_operand (operands[1], DImode))" @@ -4345,18 +4397,19 @@ ;; in FP registers (off by default, use -mdebugh to enable). (define_insn "*mov<mode>_internal" - [(set (match_operand:IMOVE32 0 "nonimmediate_operand" "=d,d,e,d,m,*f,*f,*d,*m,*d,*z,*a,*d,*B*C*D,*B*C*D,*d,*m") - (match_operand:IMOVE32 1 "move_operand" "d,U,T,m,dJ,*d*J,*m,*f,*f,*z,*d,*J*d,*a,*d,*m,*B*C*D,*B*C*D"))] + [(set (match_operand:IMOVE32 0 "nonimmediate_operand" "=d,!u,!u,d,e,!u,!ks,d,ZS,ZT,m,*f,*f,*d,*m,*d,*z,*a,*d,*B*C*D,*B*C*D,*d,*m") + (match_operand:IMOVE32 1 "move_operand" "d,J,Udb7,Yd,Yf,ZT,ZS,m,!ks,!u,dJ,*d*J,*m,*f,*f,*z,*d,*J*d,*a,*d,*m,*B*C*D,*B*C*D"))] "!TARGET_MIPS16 && (register_operand (operands[0], <MODE>mode) || reg_or_0_operand (operands[1], <MODE>mode))" { return mips_output_move (operands[0], operands[1]); } - [(set_attr "move_type" "move,const,const,load,store,mtc,fpload,mfc,fpstore,mfc,mtc,mtlo,mflo,mtc,fpload,mfc,fpstore") + [(set_attr "move_type" "move,move,const,const,const,load,load,load,store,store,store,mtc,fpload,mfc,fpstore,mfc,mtc,mtlo,mflo,mtc,fpload,mfc,fpstore") + (set_attr "compression" "all,micromips,micromips,*,*,micromips,micromips,*,micromips,micromips,*,*,*,*,*,*,*,*,*,*,*,*,*") (set_attr "mode" "SI")]) (define_insn "*mov<mode>_mips16" [(set (match_operand:IMOVE32 0 "nonimmediate_operand" "=d,y,d,d,d,d,d,d,m,*d") - (match_operand:IMOVE32 1 "move_operand" "d,d,y,K,N,U,kf,m,d,*a"))] + (match_operand:IMOVE32 1 "move_operand" "d,d,y,K,N,Yd,kf,m,d,*a"))] "TARGET_MIPS16 && (register_operand (operands[0], <MODE>mode) || register_operand (operands[1], <MODE>mode))" @@ -5208,9 +5261,9 @@ }) (define_insn "*<optab><mode>3" - [(set (match_operand:GPR 0 "register_operand" "=d") - (any_shift:GPR (match_operand:GPR 1 "register_operand" "d") - (match_operand:SI 2 "arith_operand" "dI")))] + [(set (match_operand:GPR 0 "register_operand" "=!u,d") + (any_shift:GPR (match_operand:GPR 1 "register_operand" "!u,d") + (match_operand:SI 2 "arith_operand" "Uib3,dI")))] "!TARGET_MIPS16" { if (CONST_INT_P (operands[2])) @@ -5220,6 +5273,7 @@ return "<d><insn>\t%0,%1,%2"; } [(set_attr "type" "shift") + (set_attr "compression" "<shift_compression>,none") (set_attr "mode" "<MODE>")]) (define_insn "*<optab>si3_extend" @@ -5447,6 +5501,14 @@ (pc)))] "!TARGET_MIPS16" { + /* For a simple BNEZ or BEQZ microMIPS branch. */ + if (TARGET_MICROMIPS + && operands[3] == const0_rtx + && get_attr_length (insn) <= 8) + return mips_output_conditional_branch (insn, operands, + "%*b%C1z%:\t%2,%0", + "%*b%N1z%:\t%2,%0"); + return mips_output_conditional_branch (insn, operands, MIPS_BRANCH ("b%C1", "%2,%z3,%0"), MIPS_BRANCH ("b%N1", "%2,%z3,%0")); @@ -5463,6 +5525,14 @@ (label_ref (match_operand 0 "" ""))))] "!TARGET_MIPS16" { + /* For a simple BNEZ or BEQZ microMIPS branch. */ + if (TARGET_MICROMIPS + && operands[3] == const0_rtx + && get_attr_length (insn) <= 8) + return mips_output_conditional_branch (insn, operands, + "%*b%N0z%:\t%2,%1", + "%*b%C0z%:\t%2,%1"); + return mips_output_conditional_branch (insn, operands, MIPS_BRANCH ("b%N1", "%2,%z3,%0"), MIPS_BRANCH ("b%C1", "%2,%z3,%0")); @@ -5766,7 +5836,14 @@ [(set (pc) (label_ref (match_operand 0)))] "!TARGET_MIPS16 && TARGET_ABSOLUTE_JUMPS" - { return MIPS_ABSOLUTE_JUMP ("%*j\t%l0%/"); } +{ + /* Use a branch for microMIPS. The assembler will choose + a 16-bit branch, a 32-bit branch, or a 32-bit jump. */ + if (TARGET_MICROMIPS && !TARGET_ABICALLS_PIC2) + return "%*b\t%l0%/"; + else + return MIPS_ABSOLUTE_JUMP ("%*j\t%l0%/"); +} [(set_attr "type" "jump")]) (define_insn "*jump_pic" @@ -5829,7 +5906,12 @@ (define_insn "indirect_jump_<mode>" [(set (pc) (match_operand:P 0 "register_operand" "d"))] "" - "%*j\t%0%/" +{ + if (TARGET_MICROMIPS) + return "%*jr%:\t%0"; + else + return "%*j\t%0%/"; +} [(set_attr "type" "jump") (set_attr "mode" "none")]) @@ -5873,7 +5955,12 @@ (match_operand:P 0 "register_operand" "d")) (use (label_ref (match_operand 1 "" "")))] "" - "%*j\t%0%/" +{ + if (TARGET_MICROMIPS) + return "%*jr%:\t%0"; + else + return "%*j\t%0%/"; +} [(set_attr "type" "jump") (set_attr "mode" "none")]) @@ -6094,7 +6181,12 @@ [(any_return) (use (match_operand 0 "pmode_register_operand" ""))] "" - "%*j\t%0%/" +{ + if (TARGET_MICROMIPS) + return "%*jr%:\t%0"; + else + return "%*j\t%0%/"; +} [(set_attr "type" "jump") (set_attr "mode" "none")]) @@ -6350,7 +6442,12 @@ [(call (mem:SI (match_operand 0 "call_insn_operand" "j,S")) (match_operand 1 "" ""))] "TARGET_SIBCALLS && SIBLING_CALL_P (insn)" - { return MIPS_CALL ("j", operands, 0, 1); } +{ + if (TARGET_MICROMIPS) + return MICROMIPS_J ("j", operands, 0); + else + return MIPS_CALL ("j", operands, 0, 1); +} [(set_attr "jal" "indirect,direct") (set_attr "jal_macro" "no")]) @@ -6371,7 +6468,12 @@ (call (mem:SI (match_operand 1 "call_insn_operand" "j,S")) (match_operand 2 "" "")))] "TARGET_SIBCALLS && SIBLING_CALL_P (insn)" - { return MIPS_CALL ("j", operands, 1, 2); } +{ + if (TARGET_MICROMIPS) + return MICROMIPS_J ("j", operands, 1); + else + return MIPS_CALL ("j", operands, 1, 2); +} [(set_attr "jal" "indirect,direct") (set_attr "jal_macro" "no")]) @@ -6383,7 +6485,12 @@ (call (mem:SI (match_dup 1)) (match_dup 2)))] "TARGET_SIBCALLS && SIBLING_CALL_P (insn)" - { return MIPS_CALL ("j", operands, 1, 2); } +{ + if (TARGET_MICROMIPS) + return MICROMIPS_J ("j", operands, 1); + else + return MIPS_CALL ("j", operands, 1, 2); +} [(set_attr "jal" "indirect,direct") (set_attr "jal_macro" "no")]) @@ -6629,7 +6736,7 @@ (define_insn "prefetch" - [(prefetch (match_operand:QI 0 "address_operand" "p") + [(prefetch (match_operand:QI 0 "address_operand" "ZD") (match_operand 1 "const_int_operand" "n") (match_operand 2 "const_int_operand" "n"))] "ISA_HAS_PREFETCH && TARGET_EXPLICIT_RELOCS" @@ -6922,6 +7029,9 @@ ; MIPS fixed-point instructions. (include "mips-fixed.md") +; microMIPS patterns. +(include "micromips.md") + ; ST-Microelectronics Loongson-2E/2F-specific patterns. (include "loongson.md") diff --git a/gcc/config/mips/mips.opt b/gcc/config/mips/mips.opt index d8ef2e7712e..f9e88b3cd72 100644 --- a/gcc/config/mips/mips.opt +++ b/gcc/config/mips/mips.opt @@ -217,9 +217,13 @@ mhard-float Target Report RejectNegative InverseMask(SOFT_FLOAT_ABI, HARD_FLOAT_ABI) Allow the use of hardware floating-point ABI and instructions +minterlink-compressed +Target Report Var(TARGET_INTERLINK_COMPRESSED) Init(0) +Generate code that is link-compatible with MIPS16 and microMIPS code. + minterlink-mips16 -Target Report Var(TARGET_INTERLINK_MIPS16) Init(0) -Generate code that can be safely linked with MIPS16 code. +Target Report Var(TARGET_INTERLINK_COMPRESSED) Init(0) +An alias for minterlink-compressed provided for backward-compatibility. mips Target RejectNegative Joined ToLower Enum(mips_mips_opt_value) Var(mips_isa_option) @@ -261,6 +265,10 @@ mmemcpy Target Report Mask(MEMCPY) Don't optimize block moves +mmicromips +Target Report Mask(MICROMIPS) +Use microMIPS instructions + mmt Target Report Var(TARGET_MT) Allow the use of MT instructions diff --git a/gcc/config/mips/predicates.md b/gcc/config/mips/predicates.md index 397d541f9be..57996fa8960 100644 --- a/gcc/config/mips/predicates.md +++ b/gcc/config/mips/predicates.md @@ -122,6 +122,98 @@ ? M16_REG_P (REGNO (op)) : GP_REG_P (REGNO (op))"))) +(define_predicate "lwsp_swsp_operand" + (and (match_code "mem") + (match_test "lwsp_swsp_address_p (XEXP (op, 0), mode)"))) + +(define_predicate "lw16_sw16_operand" + (and (match_code "mem") + (match_test "m16_based_address_p (XEXP (op, 0), mode, uw4_operand)"))) + +(define_predicate "lhu16_sh16_operand" + (and (match_code "mem") + (match_test "m16_based_address_p (XEXP (op, 0), mode, uh4_operand)"))) + +(define_predicate "lbu16_operand" + (and (match_code "mem") + (match_test "m16_based_address_p (XEXP (op, 0), mode, db4_operand)"))) + +(define_predicate "sb16_operand" + (and (match_code "mem") + (match_test "m16_based_address_p (XEXP (op, 0), mode, ub4_operand)"))) + +(define_predicate "db4_operand" + (and (match_code "const_int") + (match_test "mips_unsigned_immediate_p (INTVAL (op) + 1, 4, 0)"))) + +(define_predicate "db7_operand" + (and (match_code "const_int") + (match_test "mips_unsigned_immediate_p (INTVAL (op) + 1, 7, 0)"))) + +(define_predicate "ib3_operand" + (and (match_code "const_int") + (match_test "mips_unsigned_immediate_p (INTVAL (op) - 1, 3, 0)"))) + +(define_predicate "sb4_operand" + (and (match_code "const_int") + (match_test "mips_signed_immediate_p (INTVAL (op), 4, 0)"))) + +(define_predicate "ub4_operand" + (and (match_code "const_int") + (match_test "mips_unsigned_immediate_p (INTVAL (op), 4, 0)"))) + +(define_predicate "uh4_operand" + (and (match_code "const_int") + (match_test "mips_unsigned_immediate_p (INTVAL (op), 4, 1)"))) + +(define_predicate "uw4_operand" + (and (match_code "const_int") + (match_test "mips_unsigned_immediate_p (INTVAL (op), 4, 2)"))) + +(define_predicate "uw5_operand" + (and (match_code "const_int") + (match_test "mips_unsigned_immediate_p (INTVAL (op), 5, 2)"))) + +(define_predicate "uw6_operand" + (and (match_code "const_int") + (match_test "mips_unsigned_immediate_p (INTVAL (op), 6, 2)"))) + +(define_predicate "addiur2_operand" + (and (match_code "const_int") + (ior (match_test "INTVAL (op) == -1") + (match_test "INTVAL (op) == 1") + (match_test "INTVAL (op) == 4") + (match_test "INTVAL (op) == 8") + (match_test "INTVAL (op) == 12") + (match_test "INTVAL (op) == 16") + (match_test "INTVAL (op) == 20") + (match_test "INTVAL (op) == 24")))) + +(define_predicate "addiusp_operand" + (and (match_code "const_int") + (ior (match_test "(IN_RANGE (INTVAL (op), 2, 257))") + (match_test "(IN_RANGE (INTVAL (op), -258, -3))")))) + +(define_predicate "andi16_operand" + (and (match_code "const_int") + (ior (match_test "IN_RANGE (INTVAL (op), 1, 4)") + (match_test "IN_RANGE (INTVAL (op), 7, 8)") + (match_test "IN_RANGE (INTVAL (op), 15, 16)") + (match_test "IN_RANGE (INTVAL (op), 31, 32)") + (match_test "IN_RANGE (INTVAL (op), 63, 64)") + (match_test "INTVAL (op) == 255") + (match_test "INTVAL (op) == 32768") + (match_test "INTVAL (op) == 65535")))) + +(define_predicate "movep_src_register" + (and (match_code "reg") + (ior (match_test ("IN_RANGE (REGNO (op), 2, 3)")) + (match_test ("IN_RANGE (REGNO (op), 16, 20)"))))) + +(define_predicate "movep_src_operand" + (ior (match_operand 0 "const_0_operand") + (match_operand 0 "movep_src_register"))) + (define_predicate "lo_operand" (and (match_code "reg") (match_test "REGNO (op) == LO_REGNUM"))) @@ -371,3 +463,8 @@ (define_predicate "mem_noofs_operand" (and (match_code "mem") (match_code "reg" "0"))) + +;; Return 1 if the operand is in non-volatile memory. +(define_predicate "non_volatile_mem_operand" + (and (match_operand 0 "memory_operand") + (not (match_test "MEM_VOLATILE_P (op)")))) diff --git a/gcc/config/mips/sync.md b/gcc/config/mips/sync.md index 3cd8343ef45..d40c2246bb1 100644 --- a/gcc/config/mips/sync.md +++ b/gcc/config/mips/sync.md @@ -59,7 +59,7 @@ ;; Can be removed in favor of atomic_compare_and_swap below. (define_insn "sync_compare_and_swap<mode>" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (match_operand:GPR 1 "memory_operand" "+R,R")) + (match_operand:GPR 1 "memory_operand" "+ZR,ZR")) (set (match_dup 1) (unspec_volatile:GPR [(match_operand:GPR 2 "reg_or_0_operand" "dJ,dJ") (match_operand:GPR 3 "arith_operand" "I,d")] @@ -89,7 +89,7 @@ ;; Helper insn for mips_expand_atomic_qihi. (define_insn "compare_and_swap_12" [(set (match_operand:SI 0 "register_operand" "=&d,&d") - (match_operand:SI 1 "memory_operand" "+R,R")) + (match_operand:SI 1 "memory_operand" "+ZR,ZR")) (set (match_dup 1) (unspec_volatile:SI [(match_operand:SI 2 "register_operand" "d,d") (match_operand:SI 3 "register_operand" "d,d") @@ -106,7 +106,7 @@ (set_attr "sync_insn1_op2" "5")]) (define_insn "sync_add<mode>" - [(set (match_operand:GPR 0 "memory_operand" "+R,R") + [(set (match_operand:GPR 0 "memory_operand" "+ZR,ZR") (unspec_volatile:GPR [(plus:GPR (match_dup 0) (match_operand:GPR 1 "arith_operand" "I,d"))] @@ -134,7 +134,7 @@ ;; Helper insn for sync_<optab><mode> (define_insn "sync_<optab>_12" - [(set (match_operand:SI 0 "memory_operand" "+R") + [(set (match_operand:SI 0 "memory_operand" "+ZR") (unspec_volatile:SI [(match_operand:SI 1 "register_operand" "d") (match_operand:SI 2 "register_operand" "d") @@ -174,7 +174,7 @@ ;; Helper insn for sync_old_<optab><mode> (define_insn "sync_old_<optab>_12" [(set (match_operand:SI 0 "register_operand" "=&d") - (match_operand:SI 1 "memory_operand" "+R")) + (match_operand:SI 1 "memory_operand" "+ZR")) (set (match_dup 1) (unspec_volatile:SI [(match_operand:SI 2 "register_operand" "d") @@ -217,7 +217,7 @@ (define_insn "sync_new_<optab>_12" [(set (match_operand:SI 0 "register_operand" "=&d") (unspec_volatile:SI - [(match_operand:SI 1 "memory_operand" "+R") + [(match_operand:SI 1 "memory_operand" "+ZR") (match_operand:SI 2 "register_operand" "d") (match_operand:SI 3 "register_operand" "d") (atomic_hiqi_op:SI (match_dup 0) @@ -257,7 +257,7 @@ ;; Helper insn for sync_nand<mode> (define_insn "sync_nand_12" - [(set (match_operand:SI 0 "memory_operand" "+R") + [(set (match_operand:SI 0 "memory_operand" "+ZR") (unspec_volatile:SI [(match_operand:SI 1 "register_operand" "d") (match_operand:SI 2 "register_operand" "d") @@ -296,7 +296,7 @@ ;; Helper insn for sync_old_nand<mode> (define_insn "sync_old_nand_12" [(set (match_operand:SI 0 "register_operand" "=&d") - (match_operand:SI 1 "memory_operand" "+R")) + (match_operand:SI 1 "memory_operand" "+ZR")) (set (match_dup 1) (unspec_volatile:SI [(match_operand:SI 2 "register_operand" "d") @@ -337,7 +337,7 @@ (define_insn "sync_new_nand_12" [(set (match_operand:SI 0 "register_operand" "=&d") (unspec_volatile:SI - [(match_operand:SI 1 "memory_operand" "+R") + [(match_operand:SI 1 "memory_operand" "+ZR") (match_operand:SI 2 "register_operand" "d") (match_operand:SI 3 "register_operand" "d") (match_operand:SI 4 "reg_or_0_operand" "dJ")] @@ -360,7 +360,7 @@ (set_attr "sync_insn1_op2" "4")]) (define_insn "sync_sub<mode>" - [(set (match_operand:GPR 0 "memory_operand" "+R") + [(set (match_operand:GPR 0 "memory_operand" "+ZR") (unspec_volatile:GPR [(minus:GPR (match_dup 0) (match_operand:GPR 1 "register_operand" "d"))] @@ -374,7 +374,7 @@ ;; Can be removed in favor of atomic_fetch_add below. (define_insn "sync_old_add<mode>" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (match_operand:GPR 1 "memory_operand" "+R,R")) + (match_operand:GPR 1 "memory_operand" "+ZR,ZR")) (set (match_dup 1) (unspec_volatile:GPR [(plus:GPR (match_dup 1) @@ -389,7 +389,7 @@ (define_insn "sync_old_sub<mode>" [(set (match_operand:GPR 0 "register_operand" "=&d") - (match_operand:GPR 1 "memory_operand" "+R")) + (match_operand:GPR 1 "memory_operand" "+ZR")) (set (match_dup 1) (unspec_volatile:GPR [(minus:GPR (match_dup 1) @@ -404,7 +404,7 @@ (define_insn "sync_new_add<mode>" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (plus:GPR (match_operand:GPR 1 "memory_operand" "+R,R") + (plus:GPR (match_operand:GPR 1 "memory_operand" "+ZR,ZR") (match_operand:GPR 2 "arith_operand" "I,d"))) (set (match_dup 1) (unspec_volatile:GPR @@ -420,7 +420,7 @@ (define_insn "sync_new_sub<mode>" [(set (match_operand:GPR 0 "register_operand" "=&d") - (minus:GPR (match_operand:GPR 1 "memory_operand" "+R") + (minus:GPR (match_operand:GPR 1 "memory_operand" "+ZR") (match_operand:GPR 2 "register_operand" "d"))) (set (match_dup 1) (unspec_volatile:GPR @@ -435,7 +435,7 @@ (set_attr "sync_insn1_op2" "2")]) (define_insn "sync_<optab><mode>" - [(set (match_operand:GPR 0 "memory_operand" "+R,R") + [(set (match_operand:GPR 0 "memory_operand" "+ZR,ZR") (unspec_volatile:GPR [(fetchop_bit:GPR (match_operand:GPR 1 "uns_arith_operand" "K,d") (match_dup 0))] @@ -448,7 +448,7 @@ (define_insn "sync_old_<optab><mode>" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (match_operand:GPR 1 "memory_operand" "+R,R")) + (match_operand:GPR 1 "memory_operand" "+ZR,ZR")) (set (match_dup 1) (unspec_volatile:GPR [(fetchop_bit:GPR (match_operand:GPR 2 "uns_arith_operand" "K,d") @@ -463,7 +463,7 @@ (define_insn "sync_new_<optab><mode>" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (match_operand:GPR 1 "memory_operand" "+R,R")) + (match_operand:GPR 1 "memory_operand" "+ZR,ZR")) (set (match_dup 1) (unspec_volatile:GPR [(fetchop_bit:GPR (match_operand:GPR 2 "uns_arith_operand" "K,d") @@ -478,7 +478,7 @@ (set_attr "sync_insn1_op2" "2")]) (define_insn "sync_nand<mode>" - [(set (match_operand:GPR 0 "memory_operand" "+R,R") + [(set (match_operand:GPR 0 "memory_operand" "+ZR,ZR") (unspec_volatile:GPR [(match_operand:GPR 1 "uns_arith_operand" "K,d")] UNSPEC_SYNC_OLD_OP))] "GENERATE_LL_SC" @@ -490,7 +490,7 @@ (define_insn "sync_old_nand<mode>" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (match_operand:GPR 1 "memory_operand" "+R,R")) + (match_operand:GPR 1 "memory_operand" "+ZR,ZR")) (set (match_dup 1) (unspec_volatile:GPR [(match_operand:GPR 2 "uns_arith_operand" "K,d")] UNSPEC_SYNC_OLD_OP))] @@ -504,7 +504,7 @@ (define_insn "sync_new_nand<mode>" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (match_operand:GPR 1 "memory_operand" "+R,R")) + (match_operand:GPR 1 "memory_operand" "+ZR,ZR")) (set (match_dup 1) (unspec_volatile:GPR [(match_operand:GPR 2 "uns_arith_operand" "K,d")] UNSPEC_SYNC_NEW_OP))] @@ -519,7 +519,7 @@ (define_insn "sync_lock_test_and_set<mode>" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (match_operand:GPR 1 "memory_operand" "+R,R")) + (match_operand:GPR 1 "memory_operand" "+ZR,ZR")) (set (match_dup 1) (unspec_volatile:GPR [(match_operand:GPR 2 "arith_operand" "I,d")] UNSPEC_SYNC_EXCHANGE))] @@ -546,7 +546,7 @@ (define_insn "test_and_set_12" [(set (match_operand:SI 0 "register_operand" "=&d") - (match_operand:SI 1 "memory_operand" "+R")) + (match_operand:SI 1 "memory_operand" "+ZR")) (set (match_dup 1) (unspec_volatile:SI [(match_operand:SI 2 "register_operand" "d") (match_operand:SI 3 "register_operand" "d") @@ -576,7 +576,7 @@ ;; TODO: the obscuring unspec can be relaxed for permissive memory ;; models. ;; Same applies to other atomic_* patterns. - (unspec_volatile:GPR [(match_operand:GPR 2 "memory_operand" "+R,R") + (unspec_volatile:GPR [(match_operand:GPR 2 "memory_operand" "+ZR,ZR") (match_operand:GPR 3 "reg_or_0_operand" "dJ,dJ")] UNSPEC_ATOMIC_COMPARE_AND_SWAP)) (set (match_operand:GPR 1 "register_operand" "=&d,&d") @@ -629,7 +629,7 @@ (define_insn "atomic_exchange<mode>_llsc" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (unspec_volatile:GPR [(match_operand:GPR 1 "memory_operand" "+R,R")] + (unspec_volatile:GPR [(match_operand:GPR 1 "memory_operand" "+ZR,ZR")] UNSPEC_ATOMIC_EXCHANGE)) (set (match_dup 1) (unspec_volatile:GPR [(match_operand:GPR 2 "arith_operand" "I,d")] @@ -684,7 +684,7 @@ (define_insn "atomic_fetch_add<mode>_llsc" [(set (match_operand:GPR 0 "register_operand" "=&d,&d") - (unspec_volatile:GPR [(match_operand:GPR 1 "memory_operand" "+R,R")] + (unspec_volatile:GPR [(match_operand:GPR 1 "memory_operand" "+ZR,ZR")] UNSPEC_ATOMIC_FETCH_OP)) (set (match_dup 1) (unspec_volatile:GPR diff --git a/gcc/config/mips/t-sde b/gcc/config/mips/t-sde index 075f8f3da67..15f506f8afe 100644 --- a/gcc/config/mips/t-sde +++ b/gcc/config/mips/t-sde @@ -16,8 +16,8 @@ # along with GCC; see the file COPYING3. If not see # <http://www.gnu.org/licenses/>. -MULTILIB_OPTIONS = EL/EB mips32/mips32r2/mips64/mips64r2 mips16 msoft-float/mfp64 mcode-readable=no -MULTILIB_DIRNAMES = el eb mips32 mips32r2 mips64 mips64r2 mips16 sof f64 spram +MULTILIB_OPTIONS = EL/EB mips32/mips32r2/mips64/mips64r2 mips16/mmicromips msoft-float/mfp64 mcode-readable=no +MULTILIB_DIRNAMES = el eb mips32 mips32r2 mips64 mips64r2 mips16 micromips sof f64 spram MULTILIB_MATCHES = EL=mel EB=meb # The -mfp64 option is only valid in conjunction with -mips32r2. diff --git a/gcc/config/mmix/mmix.c b/gcc/config/mmix/mmix.c index 1a81d4cde16..1af09e559b0 100644 --- a/gcc/config/mmix/mmix.c +++ b/gcc/config/mmix/mmix.c @@ -1728,7 +1728,7 @@ mmix_print_operand (FILE *stream, rtx x, int code) if (CONSTANT_P (modified_x) /* Strangely enough, this is not included in CONSTANT_P. FIXME: Ask/check about sanity here. */ - || GET_CODE (modified_x) == CODE_LABEL) + || LABEL_P (modified_x)) { output_addr_const (stream, modified_x); return; 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/pa/pa.c b/gcc/config/pa/pa.c index 0d39483d908..1cad695cf0d 100644 --- a/gcc/config/pa/pa.c +++ b/gcc/config/pa/pa.c @@ -3320,7 +3320,7 @@ remove_useless_addtr_insns (int check_notes) rtx tmp; /* Ignore anything that isn't an INSN or a JUMP_INSN. */ - if (GET_CODE (insn) != INSN && GET_CODE (insn) != JUMP_INSN) + if (! NONJUMP_INSN_P (insn) && ! JUMP_P (insn)) continue; tmp = PATTERN (insn); @@ -3359,7 +3359,7 @@ remove_useless_addtr_insns (int check_notes) rtx tmp, next; /* Ignore anything that isn't an INSN. */ - if (GET_CODE (insn) != INSN) + if (! NONJUMP_INSN_P (insn)) continue; tmp = PATTERN (insn); @@ -3382,13 +3382,11 @@ remove_useless_addtr_insns (int check_notes) while (next) { /* Jumps, calls and labels stop our search. */ - if (GET_CODE (next) == JUMP_INSN - || GET_CODE (next) == CALL_INSN - || GET_CODE (next) == CODE_LABEL) + if (JUMP_P (next) || CALL_P (next) || LABEL_P (next)) break; /* As does another fcmp insn. */ - if (GET_CODE (next) == INSN + if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SET && GET_CODE (SET_DEST (PATTERN (next))) == REG && REGNO (SET_DEST (PATTERN (next))) == 0) @@ -3398,8 +3396,7 @@ remove_useless_addtr_insns (int check_notes) } /* Is NEXT_INSN a branch? */ - if (next - && GET_CODE (next) == JUMP_INSN) + if (next && JUMP_P (next)) { rtx pattern = PATTERN (next); @@ -4160,16 +4157,16 @@ pa_output_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED) always point to a valid instruction in the current function. */ /* Get the last real insn. */ - if (GET_CODE (insn) == NOTE) + if (NOTE_P (insn)) insn = prev_real_insn (insn); /* If it is a sequence, then look inside. */ - if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE) + if (insn && NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE) insn = XVECEXP (PATTERN (insn), 0, 0); /* If insn is a CALL_INSN, then it must be a call to a volatile function (otherwise there would be epilogue insns). */ - if (insn && GET_CODE (insn) == CALL_INSN) + if (insn && CALL_P (insn)) { fputs ("\tnop\n", file); last_address += 4; @@ -4930,12 +4927,12 @@ pa_adjust_insn_length (rtx insn, int length) /* Jumps inside switch tables which have unfilled delay slots need adjustment. */ - if (GET_CODE (insn) == JUMP_INSN + if (JUMP_P (insn) && GET_CODE (pat) == PARALLEL && get_attr_type (insn) == TYPE_BTABLE_BRANCH) length += 4; /* Block move pattern. */ - else if (GET_CODE (insn) == INSN + else if (NONJUMP_INSN_P (insn) && GET_CODE (pat) == PARALLEL && GET_CODE (XVECEXP (pat, 0, 0)) == SET && GET_CODE (XEXP (XVECEXP (pat, 0, 0), 0)) == MEM @@ -4944,7 +4941,7 @@ pa_adjust_insn_length (rtx insn, int length) && GET_MODE (XEXP (XVECEXP (pat, 0, 0), 1)) == BLKmode) length += compute_movmem_length (insn) - 4; /* Block clear pattern. */ - else if (GET_CODE (insn) == INSN + else if (NONJUMP_INSN_P (insn) && GET_CODE (pat) == PARALLEL && GET_CODE (XVECEXP (pat, 0, 0)) == SET && GET_CODE (XEXP (XVECEXP (pat, 0, 0), 0)) == MEM @@ -4952,7 +4949,7 @@ pa_adjust_insn_length (rtx insn, int length) && GET_MODE (XEXP (XVECEXP (pat, 0, 0), 0)) == BLKmode) length += compute_clrmem_length (insn) - 4; /* Conditional branch with an unfilled delay slot. */ - else if (GET_CODE (insn) == JUMP_INSN && ! simplejump_p (insn)) + else if (JUMP_P (insn) && ! simplejump_p (insn)) { /* Adjust a short backwards conditional with an unfilled delay slot. */ if (GET_CODE (pat) == SET @@ -5846,7 +5843,7 @@ pa_output_arg_descriptor (rtx call_insn) return; } - gcc_assert (GET_CODE (call_insn) == CALL_INSN); + gcc_assert (CALL_P (call_insn)); for (link = CALL_INSN_FUNCTION_USAGE (call_insn); link; link = XEXP (link, 1)) { @@ -6641,7 +6638,7 @@ pa_output_lbranch (rtx dest, rtx insn, int xdelay) if (xdelay && dbr_sequence_length () != 0) { /* We can't handle a jump in the delay slot. */ - gcc_assert (GET_CODE (NEXT_INSN (insn)) != JUMP_INSN); + gcc_assert (! JUMP_P (NEXT_INSN (insn))); final_scan_insn (NEXT_INSN (insn), asm_out_file, optimize, 0, NULL); @@ -7650,7 +7647,7 @@ pa_output_millicode_call (rtx insn, rtx call_dest) output_asm_insn ("nop", xoperands); /* We are done if there isn't a jump in the delay slot. */ - if (seq_length == 0 || GET_CODE (NEXT_INSN (insn)) != JUMP_INSN) + if (seq_length == 0 || ! JUMP_P (NEXT_INSN (insn))) return ""; /* This call has an unconditional jump in its delay slot. */ @@ -7708,7 +7705,7 @@ pa_attr_length_call (rtx insn, int sibcall) rtx pat = PATTERN (insn); unsigned long distance = -1; - gcc_assert (GET_CODE (insn) == CALL_INSN); + gcc_assert (CALL_P (insn)); if (INSN_ADDRESSES_SET_P ()) { @@ -7822,7 +7819,7 @@ pa_output_call (rtx insn, rtx call_dest, int sibcall) delay slot. We can't do this in a sibcall as we don't have a second call-clobbered scratch register available. */ if (seq_length != 0 - && GET_CODE (NEXT_INSN (insn)) != JUMP_INSN + && ! JUMP_P (NEXT_INSN (insn)) && !sibcall) { final_scan_insn (NEXT_INSN (insn), asm_out_file, @@ -7866,7 +7863,7 @@ pa_output_call (rtx insn, rtx call_dest, int sibcall) indirect_call = 1; if (seq_length != 0 - && GET_CODE (NEXT_INSN (insn)) != JUMP_INSN + && ! JUMP_P (NEXT_INSN (insn)) && !sibcall && (!TARGET_PA_20 || indirect_call @@ -8032,7 +8029,7 @@ pa_output_call (rtx insn, rtx call_dest, int sibcall) /* We are done if there isn't a jump in the delay slot. */ if (seq_length == 0 || delay_insn_deleted - || GET_CODE (NEXT_INSN (insn)) != JUMP_INSN) + || ! JUMP_P (NEXT_INSN (insn))) return ""; /* A sibcall should never have a branch in the delay slot. */ @@ -8826,12 +8823,12 @@ int pa_jump_in_call_delay (rtx insn) { - if (GET_CODE (insn) != JUMP_INSN) + if (! JUMP_P (insn)) return 0; if (PREV_INSN (insn) && PREV_INSN (PREV_INSN (insn)) - && GET_CODE (next_real_insn (PREV_INSN (PREV_INSN (insn)))) == INSN) + && NONJUMP_INSN_P (next_real_insn (PREV_INSN (PREV_INSN (insn))))) { rtx test_insn = next_real_insn (PREV_INSN (PREV_INSN (insn))); @@ -8928,14 +8925,14 @@ pa_following_call (rtx insn) /* Find the previous real insn, skipping NOTEs. */ insn = PREV_INSN (insn); - while (insn && GET_CODE (insn) == NOTE) + while (insn && NOTE_P (insn)) insn = PREV_INSN (insn); /* Check for CALL_INSNs and millicode calls. */ if (insn - && ((GET_CODE (insn) == CALL_INSN + && ((CALL_P (insn) && get_attr_type (insn) != TYPE_DYNCALL) - || (GET_CODE (insn) == INSN + || (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) != SEQUENCE && GET_CODE (PATTERN (insn)) != USE && GET_CODE (PATTERN (insn)) != CLOBBER @@ -9000,7 +8997,7 @@ pa_reorg (void) unsigned int length, i; /* Find an ADDR_VEC or ADDR_DIFF_VEC insn to explode. */ - if (GET_CODE (insn) != JUMP_INSN + if (! JUMP_P (insn) || (GET_CODE (PATTERN (insn)) != ADDR_VEC && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)) continue; @@ -9059,7 +9056,7 @@ pa_reorg (void) for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) { /* Find an ADDR_VEC insn. */ - if (GET_CODE (insn) != JUMP_INSN + if (! JUMP_P (insn) || (GET_CODE (PATTERN (insn)) != ADDR_VEC && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)) continue; @@ -9140,9 +9137,7 @@ pa_combine_instructions (void) /* We only care about INSNs, JUMP_INSNs, and CALL_INSNs. Also ignore any special USE insns. */ - if ((GET_CODE (anchor) != INSN - && GET_CODE (anchor) != JUMP_INSN - && GET_CODE (anchor) != CALL_INSN) + if ((! NONJUMP_INSN_P (anchor) && ! JUMP_P (anchor) && ! CALL_P (anchor)) || GET_CODE (PATTERN (anchor)) == USE || GET_CODE (PATTERN (anchor)) == CLOBBER || GET_CODE (PATTERN (anchor)) == ADDR_VEC @@ -9162,14 +9157,14 @@ pa_combine_instructions (void) floater; floater = PREV_INSN (floater)) { - if (GET_CODE (floater) == NOTE - || (GET_CODE (floater) == INSN + if (NOTE_P (floater) + || (NONJUMP_INSN_P (floater) && (GET_CODE (PATTERN (floater)) == USE || GET_CODE (PATTERN (floater)) == CLOBBER))) continue; /* Anything except a regular INSN will stop our search. */ - if (GET_CODE (floater) != INSN + if (! NONJUMP_INSN_P (floater) || GET_CODE (PATTERN (floater)) == ADDR_VEC || GET_CODE (PATTERN (floater)) == ADDR_DIFF_VEC) { @@ -9223,15 +9218,15 @@ pa_combine_instructions (void) { for (floater = anchor; floater; floater = NEXT_INSN (floater)) { - if (GET_CODE (floater) == NOTE - || (GET_CODE (floater) == INSN + if (NOTE_P (floater) + || (NONJUMP_INSN_P (floater) && (GET_CODE (PATTERN (floater)) == USE || GET_CODE (PATTERN (floater)) == CLOBBER))) continue; /* Anything except a regular INSN will stop our search. */ - if (GET_CODE (floater) != INSN + if (! NONJUMP_INSN_P (floater) || GET_CODE (PATTERN (floater)) == ADDR_VEC || GET_CODE (PATTERN (floater)) == ADDR_DIFF_VEC) { @@ -9386,7 +9381,7 @@ pa_can_combine_p (rtx new_rtx, rtx anchor, rtx floater, int reversed, rtx dest, int pa_insn_refs_are_delayed (rtx insn) { - return ((GET_CODE (insn) == INSN + return ((NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) != SEQUENCE && GET_CODE (PATTERN (insn)) != USE && GET_CODE (PATTERN (insn)) != CLOBBER diff --git a/gcc/config/rs6000/constraints.md b/gcc/config/rs6000/constraints.md index ccb61edce45..463d69c6ba4 100644 --- a/gcc/config/rs6000/constraints.md +++ b/gcc/config/rs6000/constraints.md @@ -64,10 +64,27 @@ (define_register_constraint "ws" "rs6000_constraints[RS6000_CONSTRAINT_ws]" "@internal") +;; TImode in VSX registers +(define_register_constraint "wt" "rs6000_constraints[RS6000_CONSTRAINT_wt]" + "@internal") + ;; any VSX register (define_register_constraint "wa" "rs6000_constraints[RS6000_CONSTRAINT_wa]" "@internal") +;; Register constraints to simplify move patterns +(define_register_constraint "wg" "rs6000_constraints[RS6000_CONSTRAINT_wg]" + "Floating point register if -mmfpgpr is used, or NO_REGS.") + +(define_register_constraint "wl" "rs6000_constraints[RS6000_CONSTRAINT_wl]" + "Floating point register if the LFIWAX instruction is enabled or NO_REGS.") + +(define_register_constraint "wx" "rs6000_constraints[RS6000_CONSTRAINT_wx]" + "Floating point register if the STFIWX instruction is enabled or NO_REGS.") + +(define_register_constraint "wz" "rs6000_constraints[RS6000_CONSTRAINT_wz]" + "Floating point register if the LFIWZX instruction is enabled or NO_REGS.") + ;; Altivec style load/store that ignores the bottom bits of the address (define_memory_constraint "wZ" "Indexed or indirect memory operand, ignoring the bottom 4 bits" diff --git a/gcc/config/rs6000/dfp.md b/gcc/config/rs6000/dfp.md index f73e115e342..052ac482e0f 100644 --- a/gcc/config/rs6000/dfp.md +++ b/gcc/config/rs6000/dfp.md @@ -29,77 +29,6 @@ ]) -(define_expand "movsd" - [(set (match_operand:SD 0 "nonimmediate_operand" "") - (match_operand:SD 1 "any_operand" ""))] - "TARGET_HARD_FLOAT && TARGET_FPRS" - "{ rs6000_emit_move (operands[0], operands[1], SDmode); DONE; }") - -(define_split - [(set (match_operand:SD 0 "gpc_reg_operand" "") - (match_operand:SD 1 "const_double_operand" ""))] - "reload_completed - && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31) - || (GET_CODE (operands[0]) == SUBREG - && GET_CODE (SUBREG_REG (operands[0])) == REG - && REGNO (SUBREG_REG (operands[0])) <= 31))" - [(set (match_dup 2) (match_dup 3))] - " -{ - long l; - REAL_VALUE_TYPE rv; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]); - REAL_VALUE_TO_TARGET_DECIMAL32 (rv, l); - - if (! TARGET_POWERPC64) - operands[2] = operand_subword (operands[0], 0, 0, SDmode); - else - operands[2] = gen_lowpart (SImode, operands[0]); - - operands[3] = gen_int_mode (l, SImode); -}") - -(define_insn "movsd_hardfloat" - [(set (match_operand:SD 0 "nonimmediate_operand" "=r,r,m,f,*c*l,!r,*h,!r,!r") - (match_operand:SD 1 "input_operand" "r,m,r,f,r,h,0,G,Fn"))] - "(gpc_reg_operand (operands[0], SDmode) - || gpc_reg_operand (operands[1], SDmode)) - && (TARGET_HARD_FLOAT && TARGET_FPRS)" - "@ - mr %0,%1 - lwz%U1%X1 %0,%1 - stw%U0%X0 %1,%0 - fmr %0,%1 - mt%0 %1 - mf%1 %0 - nop - # - #" - [(set_attr "type" "*,load,store,fp,mtjmpr,mfjmpr,*,*,*") - (set_attr "length" "4,4,4,4,4,4,4,4,8")]) - -(define_insn "movsd_softfloat" - [(set (match_operand:SD 0 "nonimmediate_operand" "=r,cl,r,r,m,r,r,r,r,r,*h") - (match_operand:SD 1 "input_operand" "r,r,h,m,r,I,L,R,G,Fn,0"))] - "(gpc_reg_operand (operands[0], SDmode) - || gpc_reg_operand (operands[1], SDmode)) - && (TARGET_SOFT_FLOAT || !TARGET_FPRS)" - "@ - mr %0,%1 - mt%0 %1 - mf%1 %0 - lwz%U1%X1 %0,%1 - stw%U0%X0 %1,%0 - li %0,%1 - lis %0,%v1 - la %0,%a1 - # - # - nop" - [(set_attr "type" "*,mtjmpr,mfjmpr,load,store,*,*,*,*,*,*") - (set_attr "length" "4,4,4,4,4,4,4,4,4,8,4")]) - (define_insn "movsd_store" [(set (match_operand:DD 0 "nonimmediate_operand" "=m") (unspec:DD [(match_operand:SD 1 "input_operand" "d")] @@ -108,7 +37,14 @@ || gpc_reg_operand (operands[1], SDmode)) && TARGET_HARD_FLOAT && TARGET_FPRS" "stfd%U0%X0 %1,%0" - [(set_attr "type" "fpstore") + [(set (attr "type") + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_u") + (const_string "fpstore")))) (set_attr "length" "4")]) (define_insn "movsd_load" @@ -119,7 +55,14 @@ || gpc_reg_operand (operands[1], DDmode)) && TARGET_HARD_FLOAT && TARGET_FPRS" "lfd%U1%X1 %0,%1" - [(set_attr "type" "fpload") + [(set (attr "type") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "fpload_u") + (const_string "fpload")))) (set_attr "length" "4")]) ;; Hardware support for decimal floating point operations. @@ -182,211 +125,6 @@ "fnabs %0,%1" [(set_attr "type" "fp")]) -(define_expand "movdd" - [(set (match_operand:DD 0 "nonimmediate_operand" "") - (match_operand:DD 1 "any_operand" ""))] - "" - "{ rs6000_emit_move (operands[0], operands[1], DDmode); DONE; }") - -(define_split - [(set (match_operand:DD 0 "gpc_reg_operand" "") - (match_operand:DD 1 "const_int_operand" ""))] - "! TARGET_POWERPC64 && reload_completed - && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31) - || (GET_CODE (operands[0]) == SUBREG - && GET_CODE (SUBREG_REG (operands[0])) == REG - && REGNO (SUBREG_REG (operands[0])) <= 31))" - [(set (match_dup 2) (match_dup 4)) - (set (match_dup 3) (match_dup 1))] - " -{ - int endian = (WORDS_BIG_ENDIAN == 0); - HOST_WIDE_INT value = INTVAL (operands[1]); - - operands[2] = operand_subword (operands[0], endian, 0, DDmode); - operands[3] = operand_subword (operands[0], 1 - endian, 0, DDmode); -#if HOST_BITS_PER_WIDE_INT == 32 - operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx; -#else - operands[4] = GEN_INT (value >> 32); - operands[1] = GEN_INT (((value & 0xffffffff) ^ 0x80000000) - 0x80000000); -#endif -}") - -(define_split - [(set (match_operand:DD 0 "gpc_reg_operand" "") - (match_operand:DD 1 "const_double_operand" ""))] - "! TARGET_POWERPC64 && reload_completed - && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31) - || (GET_CODE (operands[0]) == SUBREG - && GET_CODE (SUBREG_REG (operands[0])) == REG - && REGNO (SUBREG_REG (operands[0])) <= 31))" - [(set (match_dup 2) (match_dup 4)) - (set (match_dup 3) (match_dup 5))] - " -{ - int endian = (WORDS_BIG_ENDIAN == 0); - long l[2]; - REAL_VALUE_TYPE rv; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]); - REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l); - - operands[2] = operand_subword (operands[0], endian, 0, DDmode); - operands[3] = operand_subword (operands[0], 1 - endian, 0, DDmode); - operands[4] = gen_int_mode (l[endian], SImode); - operands[5] = gen_int_mode (l[1 - endian], SImode); -}") - -(define_split - [(set (match_operand:DD 0 "gpc_reg_operand" "") - (match_operand:DD 1 "const_double_operand" ""))] - "TARGET_POWERPC64 && reload_completed - && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31) - || (GET_CODE (operands[0]) == SUBREG - && GET_CODE (SUBREG_REG (operands[0])) == REG - && REGNO (SUBREG_REG (operands[0])) <= 31))" - [(set (match_dup 2) (match_dup 3))] - " -{ - int endian = (WORDS_BIG_ENDIAN == 0); - long l[2]; - REAL_VALUE_TYPE rv; -#if HOST_BITS_PER_WIDE_INT >= 64 - HOST_WIDE_INT val; -#endif - - REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]); - REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l); - - operands[2] = gen_lowpart (DImode, operands[0]); - /* HIGHPART is lower memory address when WORDS_BIG_ENDIAN. */ -#if HOST_BITS_PER_WIDE_INT >= 64 - val = ((HOST_WIDE_INT)(unsigned long)l[endian] << 32 - | ((HOST_WIDE_INT)(unsigned long)l[1 - endian])); - - operands[3] = gen_int_mode (val, DImode); -#else - operands[3] = immed_double_const (l[1 - endian], l[endian], DImode); -#endif -}") - -;; Don't have reload use general registers to load a constant. First, -;; it might not work if the output operand is the equivalent of -;; a non-offsettable memref, but also it is less efficient than loading -;; the constant into an FP register, since it will probably be used there. -;; The "??" is a kludge until we can figure out a more reasonable way -;; of handling these non-offsettable values. -(define_insn "*movdd_hardfloat32" - [(set (match_operand:DD 0 "nonimmediate_operand" "=!r,??r,m,d,d,m,!r,!r,!r") - (match_operand:DD 1 "input_operand" "r,m,r,d,m,d,G,H,F"))] - "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS - && (gpc_reg_operand (operands[0], DDmode) - || gpc_reg_operand (operands[1], DDmode))" - "* -{ - switch (which_alternative) - { - default: - gcc_unreachable (); - case 0: - case 1: - case 2: - return \"#\"; - case 3: - return \"fmr %0,%1\"; - case 4: - return \"lfd%U1%X1 %0,%1\"; - case 5: - return \"stfd%U0%X0 %1,%0\"; - case 6: - case 7: - case 8: - return \"#\"; - } -}" - [(set_attr "type" "two,load,store,fp,fpload,fpstore,*,*,*") - (set_attr "length" "8,16,16,4,4,4,8,12,16")]) - -(define_insn "*movdd_softfloat32" - [(set (match_operand:DD 0 "nonimmediate_operand" "=r,r,m,r,r,r") - (match_operand:DD 1 "input_operand" "r,m,r,G,H,F"))] - "! TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || !TARGET_FPRS) - && (gpc_reg_operand (operands[0], DDmode) - || gpc_reg_operand (operands[1], DDmode))" - "#" - [(set_attr "type" "two,load,store,*,*,*") - (set_attr "length" "8,8,8,8,12,16")]) - -; ld/std require word-aligned displacements -> 'Y' constraint. -; List Y->r and r->Y before r->r for reload. -(define_insn "*movdd_hardfloat64_mfpgpr" - [(set (match_operand:DD 0 "nonimmediate_operand" "=Y,r,!r,d,d,m,*c*l,!r,*h,!r,!r,!r,r,d") - (match_operand:DD 1 "input_operand" "r,Y,r,d,m,d,r,h,0,G,H,F,d,r"))] - "TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS - && (gpc_reg_operand (operands[0], DDmode) - || gpc_reg_operand (operands[1], DDmode))" - "@ - std%U0%X0 %1,%0 - ld%U1%X1 %0,%1 - mr %0,%1 - fmr %0,%1 - lfd%U1%X1 %0,%1 - stfd%U0%X0 %1,%0 - mt%0 %1 - mf%1 %0 - nop - # - # - # - mftgpr %0,%1 - mffgpr %0,%1" - [(set_attr "type" "store,load,*,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*,*,mftgpr,mffgpr") - (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16,4,4")]) - -; ld/std require word-aligned displacements -> 'Y' constraint. -; List Y->r and r->Y before r->r for reload. -(define_insn "*movdd_hardfloat64" - [(set (match_operand:DD 0 "nonimmediate_operand" "=Y,r,!r,d,d,m,*c*l,!r,*h,!r,!r,!r") - (match_operand:DD 1 "input_operand" "r,Y,r,d,m,d,r,h,0,G,H,F"))] - "TARGET_POWERPC64 && !TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS - && (gpc_reg_operand (operands[0], DDmode) - || gpc_reg_operand (operands[1], DDmode))" - "@ - std%U0%X0 %1,%0 - ld%U1%X1 %0,%1 - mr %0,%1 - fmr %0,%1 - lfd%U1%X1 %0,%1 - stfd%U0%X0 %1,%0 - mt%0 %1 - mf%1 %0 - nop - # - # - #" - [(set_attr "type" "store,load,*,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*,*") - (set_attr "length" "4,4,4,4,4,4,4,4,4,8,12,16")]) - -(define_insn "*movdd_softfloat64" - [(set (match_operand:DD 0 "nonimmediate_operand" "=r,Y,r,cl,r,r,r,r,*h") - (match_operand:DD 1 "input_operand" "Y,r,r,r,h,G,H,F,0"))] - "TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || !TARGET_FPRS) - && (gpc_reg_operand (operands[0], DDmode) - || gpc_reg_operand (operands[1], DDmode))" - "@ - ld%U1%X1 %0,%1 - std%U0%X0 %1,%0 - mr %0,%1 - mt%0 %1 - mf%1 %0 - # - # - # - nop" - [(set_attr "type" "load,store,*,mtjmpr,mfjmpr,*,*,*,*") - (set_attr "length" "4,4,4,4,4,8,12,16,4")]) - (define_expand "negtd2" [(set (match_operand:TD 0 "gpc_reg_operand" "") (neg:TD (match_operand:TD 1 "gpc_reg_operand" "")))] @@ -420,27 +158,6 @@ "fnabs %0,%1" [(set_attr "type" "fp")]) -(define_expand "movtd" - [(set (match_operand:TD 0 "general_operand" "") - (match_operand:TD 1 "any_operand" ""))] - "TARGET_HARD_FLOAT && TARGET_FPRS" - "{ rs6000_emit_move (operands[0], operands[1], TDmode); DONE; }") - -; It's important to list the Y->r and r->Y moves before r->r because -; otherwise reload, given m->r, will try to pick r->r and reload it, -; which doesn't make progress. -(define_insn_and_split "*movtd_internal" - [(set (match_operand:TD 0 "nonimmediate_operand" "=m,d,d,Y,r,r") - (match_operand:TD 1 "input_operand" "d,m,d,r,YGHF,r"))] - "TARGET_HARD_FLOAT && TARGET_FPRS - && (gpc_reg_operand (operands[0], TDmode) - || gpc_reg_operand (operands[1], TDmode))" - "#" - "&& reload_completed" - [(pc)] -{ rs6000_split_multireg_move (operands[0], operands[1]); DONE; } - [(set_attr "length" "8,8,8,20,20,16")]) - ;; Hardware support for decimal floating point operations. (define_insn "extendddtd2" diff --git a/gcc/config/rs6000/predicates.md b/gcc/config/rs6000/predicates.md index 868ba567976..8112f26fe19 100644 --- a/gcc/config/rs6000/predicates.md +++ b/gcc/config/rs6000/predicates.md @@ -329,6 +329,11 @@ && mode != DImode) return 1; + /* The constant 0.0 is easy under VSX. */ + if ((mode == SFmode || mode == DFmode || mode == SDmode || mode == DDmode) + && VECTOR_UNIT_VSX_P (DFmode) && op == CONST0_RTX (mode)) + return 1; + if (DECIMAL_FLOAT_MODE_P (mode)) return 0; @@ -552,6 +557,28 @@ && REG_P (XEXP (op, 1)))") (match_operand 0 "address_operand"))) +;; Return 1 if the operand is an index-form address. +(define_special_predicate "indexed_address" + (match_test "(GET_CODE (op) == PLUS + && REG_P (XEXP (op, 0)) + && REG_P (XEXP (op, 1)))")) + +;; Return 1 if the operand is a MEM with an update-form address. This may +;; also include update-indexed form. +(define_special_predicate "update_address_mem" + (match_test "(MEM_P (op) + && (GET_CODE (XEXP (op, 0)) == PRE_INC + || GET_CODE (XEXP (op, 0)) == PRE_DEC + || GET_CODE (XEXP (op, 0)) == PRE_MODIFY))")) + +;; Return 1 if the operand is a MEM with an update-indexed-form address. Note +;; that PRE_INC/PRE_DEC will always be non-indexed (i.e. non X-form) since the +;; increment is based on the mode size and will therefor always be a const. +(define_special_predicate "update_indexed_address_mem" + (match_test "(MEM_P (op) + && GET_CODE (XEXP (op, 0)) == PRE_MODIFY + && indexed_address (XEXP (XEXP (op, 0), 1), mode))")) + ;; Used for the destination of the fix_truncdfsi2 expander. ;; If stfiwx will be used, the result goes to memory; otherwise, ;; we're going to emit a store and a load of a subreg, so the dest is a diff --git a/gcc/config/rs6000/rs6000-cpus.def b/gcc/config/rs6000/rs6000-cpus.def index 3f17c6f2395..0564018b3f0 100644 --- a/gcc/config/rs6000/rs6000-cpus.def +++ b/gcc/config/rs6000/rs6000-cpus.def @@ -42,7 +42,8 @@ #define ISA_2_6_MASKS_SERVER (ISA_2_5_MASKS_SERVER \ | OPTION_MASK_POPCNTD \ | OPTION_MASK_ALTIVEC \ - | OPTION_MASK_VSX) + | OPTION_MASK_VSX \ + | OPTION_MASK_VSX_TIMODE) #define POWERPC_7400_MASK (OPTION_MASK_PPC_GFXOPT | OPTION_MASK_ALTIVEC) @@ -76,7 +77,8 @@ | OPTION_MASK_RECIP_PRECISION \ | OPTION_MASK_SOFT_FLOAT \ | OPTION_MASK_STRICT_ALIGN_OPTIONAL \ - | OPTION_MASK_VSX) + | OPTION_MASK_VSX \ + | OPTION_MASK_VSX_TIMODE) #endif @@ -165,11 +167,11 @@ RS6000_CPU ("power6x", PROCESSOR_POWER6, MASK_POWERPC64 | MASK_PPC_GPOPT RS6000_CPU ("power7", PROCESSOR_POWER7, /* Don't add MASK_ISEL by default */ POWERPC_7400_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP | MASK_POPCNTD - | MASK_VSX | MASK_RECIP_PRECISION) + | MASK_VSX | MASK_RECIP_PRECISION | MASK_VSX_TIMODE) RS6000_CPU ("power8", PROCESSOR_POWER7, /* Don't add MASK_ISEL by default */ POWERPC_7400_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP | MASK_POPCNTD - | MASK_VSX | MASK_RECIP_PRECISION) + | MASK_VSX | MASK_RECIP_PRECISION | MASK_VSX_TIMODE) RS6000_CPU ("powerpc", PROCESSOR_POWERPC, 0) RS6000_CPU ("powerpc64", PROCESSOR_POWERPC64, MASK_PPC_GFXOPT | MASK_POWERPC64) RS6000_CPU ("rs64", PROCESSOR_RS64A, MASK_PPC_GFXOPT | MASK_POWERPC64) diff --git a/gcc/config/rs6000/rs6000-modes.def b/gcc/config/rs6000/rs6000-modes.def index bc18f8a168c..54548be7038 100644 --- a/gcc/config/rs6000/rs6000-modes.def +++ b/gcc/config/rs6000/rs6000-modes.def @@ -41,3 +41,6 @@ VECTOR_MODE (INT, DI, 1); VECTOR_MODES (FLOAT, 8); /* V4HF V2SF */ VECTOR_MODES (FLOAT, 16); /* V8HF V4SF V2DF */ VECTOR_MODES (FLOAT, 32); /* V16HF V8SF V4DF */ + +/* Replacement for TImode that only is allowed in GPRs. */ +PARTIAL_INT_MODE (TI); diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index fbf57be44a3..0fe45d8b151 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -1516,8 +1516,9 @@ rs6000_hard_regno_nregs_internal (int regno, enum machine_mode mode) { unsigned HOST_WIDE_INT reg_size; + /* TF/TD modes are special in that they always take 2 registers. */ if (FP_REGNO_P (regno)) - reg_size = (VECTOR_MEM_VSX_P (mode) + reg_size = ((VECTOR_MEM_VSX_P (mode) && mode != TDmode && mode != TFmode) ? UNITS_PER_VSX_WORD : UNITS_PER_FP_WORD); @@ -1561,14 +1562,18 @@ rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode) return ALTIVEC_REGNO_P (last_regno); } + /* Allow TImode in all VSX registers if the user asked for it. Note, PTImode + can only go in GPRs. */ + if (mode == TImode && TARGET_VSX_TIMODE && VSX_REGNO_P (regno)) + return 1; + /* The GPRs can hold any mode, but values bigger than one register cannot go past R31. */ if (INT_REGNO_P (regno)) return INT_REGNO_P (last_regno); /* The float registers (except for VSX vector modes) can only hold floating - modes and DImode. This excludes the 32-bit decimal float mode for - now. */ + modes and DImode. */ if (FP_REGNO_P (regno)) { if (SCALAR_FLOAT_MODE_P (mode) @@ -1602,9 +1607,8 @@ rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode) if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode)) return 1; - /* We cannot put TImode anywhere except general register and it must be able - to fit within the register set. In the future, allow TImode in the - Altivec or VSX registers. */ + /* We cannot put non-VSX TImode or PTImode anywhere except general register + and it must be able to fit within the register set. */ return GET_MODE_SIZE (mode) <= UNITS_PER_WORD; } @@ -1693,6 +1697,7 @@ rs6000_debug_reg_global (void) static const char *const tf[2] = { "false", "true" }; const char *nl = (const char *)0; int m; + size_t m1, m2, v; char costly_num[20]; char nop_num[20]; char flags_buffer[40]; @@ -1713,10 +1718,67 @@ rs6000_debug_reg_global (void) "other" }; - fprintf (stderr, "Register information: (last virtual reg = %d)\n", - LAST_VIRTUAL_REGISTER); - rs6000_debug_reg_print (0, 31, "gr"); - rs6000_debug_reg_print (32, 63, "fp"); + /* Modes we want tieable information on. */ + static const enum machine_mode print_tieable_modes[] = { + QImode, + HImode, + SImode, + DImode, + TImode, + PTImode, + SFmode, + DFmode, + TFmode, + SDmode, + DDmode, + TDmode, + V8QImode, + V4HImode, + V2SImode, + V16QImode, + V8HImode, + V4SImode, + V2DImode, + V32QImode, + V16HImode, + V8SImode, + V4DImode, + V2SFmode, + V4SFmode, + V2DFmode, + V8SFmode, + V4DFmode, + CCmode, + CCUNSmode, + CCEQmode, + }; + + /* Virtual regs we are interested in. */ + const static struct { + int regno; /* register number. */ + const char *name; /* register name. */ + } virtual_regs[] = { + { STACK_POINTER_REGNUM, "stack pointer:" }, + { TOC_REGNUM, "toc: " }, + { STATIC_CHAIN_REGNUM, "static chain: " }, + { RS6000_PIC_OFFSET_TABLE_REGNUM, "pic offset: " }, + { HARD_FRAME_POINTER_REGNUM, "hard frame: " }, + { ARG_POINTER_REGNUM, "arg pointer: " }, + { FRAME_POINTER_REGNUM, "frame pointer:" }, + { FIRST_PSEUDO_REGISTER, "first pseudo: " }, + { FIRST_VIRTUAL_REGISTER, "first virtual:" }, + { VIRTUAL_INCOMING_ARGS_REGNUM, "incoming_args:" }, + { VIRTUAL_STACK_VARS_REGNUM, "stack_vars: " }, + { VIRTUAL_STACK_DYNAMIC_REGNUM, "stack_dynamic:" }, + { VIRTUAL_OUTGOING_ARGS_REGNUM, "outgoing_args:" }, + { VIRTUAL_CFA_REGNUM, "cfa (frame): " }, + { VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM, "stack boundry:" }, + { LAST_VIRTUAL_REGISTER, "last virtual: " }, + }; + + fputs ("\nHard register information:\n", stderr); + rs6000_debug_reg_print (FIRST_GPR_REGNO, LAST_GPR_REGNO, "gr"); + rs6000_debug_reg_print (FIRST_FPR_REGNO, LAST_FPR_REGNO, "fp"); rs6000_debug_reg_print (FIRST_ALTIVEC_REGNO, LAST_ALTIVEC_REGNO, "vs"); @@ -1729,6 +1791,10 @@ rs6000_debug_reg_global (void) rs6000_debug_reg_print (SPE_ACC_REGNO, SPE_ACC_REGNO, "spe_a"); rs6000_debug_reg_print (SPEFSCR_REGNO, SPEFSCR_REGNO, "spe_f"); + fputs ("\nVirtual/stack/frame registers:\n", stderr); + for (v = 0; v < ARRAY_SIZE (virtual_regs); v++) + fprintf (stderr, "%s regno = %3d\n", virtual_regs[v].name, virtual_regs[v].regno); + fprintf (stderr, "\n" "d reg_class = %s\n" @@ -1737,28 +1803,74 @@ rs6000_debug_reg_global (void) "wa reg_class = %s\n" "wd reg_class = %s\n" "wf reg_class = %s\n" - "ws reg_class = %s\n\n", + "wg reg_class = %s\n" + "wl reg_class = %s\n" + "ws reg_class = %s\n" + "wt reg_class = %s\n" + "wx reg_class = %s\n" + "wz reg_class = %s\n" + "\n", reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_d]], reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_f]], reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_v]], reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wa]], reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wd]], reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wf]], - reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_ws]]); + reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wg]], + reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wl]], + reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_ws]], + reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wt]], + reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wx]], + reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wz]]); for (m = 0; m < NUM_MACHINE_MODES; ++m) - if (rs6000_vector_unit[m] || rs6000_vector_mem[m]) + if (rs6000_vector_unit[m] || rs6000_vector_mem[m] + || (rs6000_vector_reload[m][0] != CODE_FOR_nothing) + || (rs6000_vector_reload[m][1] != CODE_FOR_nothing)) { nl = "\n"; - fprintf (stderr, "Vector mode: %-5s arithmetic: %-8s move: %-8s\n", + fprintf (stderr, + "Vector mode: %-5s arithmetic: %-10s move: %-10s " + "reload-out: %c reload-in: %c\n", GET_MODE_NAME (m), rs6000_debug_vector_unit[ rs6000_vector_unit[m] ], - rs6000_debug_vector_unit[ rs6000_vector_mem[m] ]); + rs6000_debug_vector_unit[ rs6000_vector_mem[m] ], + (rs6000_vector_reload[m][0] != CODE_FOR_nothing) ? 'y' : 'n', + (rs6000_vector_reload[m][1] != CODE_FOR_nothing) ? 'y' : 'n'); } if (nl) fputs (nl, stderr); + for (m1 = 0; m1 < ARRAY_SIZE (print_tieable_modes); m1++) + { + enum machine_mode mode1 = print_tieable_modes[m1]; + bool first_time = true; + + nl = (const char *)0; + for (m2 = 0; m2 < ARRAY_SIZE (print_tieable_modes); m2++) + { + enum machine_mode mode2 = print_tieable_modes[m2]; + if (mode1 != mode2 && MODES_TIEABLE_P (mode1, mode2)) + { + if (first_time) + { + fprintf (stderr, "Tieable modes %s:", GET_MODE_NAME (mode1)); + nl = "\n"; + first_time = false; + } + + fprintf (stderr, " %s", GET_MODE_NAME (mode2)); + } + } + + if (!first_time) + fputs ("\n", stderr); + } + + if (nl) + fputs (nl, stderr); + if (rs6000_recip_control) { fprintf (stderr, "\nReciprocal mask = 0x%x\n", rs6000_recip_control); @@ -1938,6 +2050,9 @@ rs6000_debug_reg_global (void) if (TARGET_LINK_STACK) fprintf (stderr, DEBUG_FMT_S, "link_stack", "true"); + if (targetm.lra_p ()) + fprintf (stderr, DEBUG_FMT_S, "lra", "true"); + fprintf (stderr, DEBUG_FMT_S, "plt-format", TARGET_SECURE_PLT ? "secure" : "bss"); fprintf (stderr, DEBUG_FMT_S, "struct-return", @@ -2083,6 +2198,13 @@ rs6000_init_hard_regno_mode_ok (bool global_init_p) rs6000_vector_align[DFmode] = align64; } + /* Allow TImode in VSX register and set the VSX memory macros. */ + if (TARGET_VSX && TARGET_VSX_TIMODE) + { + rs6000_vector_mem[TImode] = VECTOR_VSX; + rs6000_vector_align[TImode] = align64; + } + /* TODO add SPE and paired floating point vector support. */ /* Register class constraints for the constraints that depend on compile @@ -2106,11 +2228,27 @@ rs6000_init_hard_regno_mode_ok (bool global_init_p) rs6000_constraints[RS6000_CONSTRAINT_ws] = (TARGET_VSX_SCALAR_MEMORY ? VSX_REGS : FLOAT_REGS); + if (TARGET_VSX_TIMODE) + rs6000_constraints[RS6000_CONSTRAINT_wt] = VSX_REGS; } + /* Add conditional constraints based on various options, to allow us to + collapse multiple insn patterns. */ if (TARGET_ALTIVEC) rs6000_constraints[RS6000_CONSTRAINT_v] = ALTIVEC_REGS; + if (TARGET_MFPGPR) + rs6000_constraints[RS6000_CONSTRAINT_wg] = FLOAT_REGS; + + if (TARGET_LFIWAX) + rs6000_constraints[RS6000_CONSTRAINT_wl] = FLOAT_REGS; + + if (TARGET_STFIWX) + rs6000_constraints[RS6000_CONSTRAINT_wx] = FLOAT_REGS; + + if (TARGET_LFIWZX) + rs6000_constraints[RS6000_CONSTRAINT_wz] = FLOAT_REGS; + /* Set up the reload helper functions. */ if (TARGET_VSX || TARGET_ALTIVEC) { @@ -2132,6 +2270,13 @@ rs6000_init_hard_regno_mode_ok (bool global_init_p) { rs6000_vector_reload[DFmode][0] = CODE_FOR_reload_df_di_store; rs6000_vector_reload[DFmode][1] = CODE_FOR_reload_df_di_load; + rs6000_vector_reload[DDmode][0] = CODE_FOR_reload_dd_di_store; + rs6000_vector_reload[DDmode][1] = CODE_FOR_reload_dd_di_load; + } + if (TARGET_VSX_TIMODE) + { + rs6000_vector_reload[TImode][0] = CODE_FOR_reload_ti_di_store; + rs6000_vector_reload[TImode][1] = CODE_FOR_reload_ti_di_load; } } else @@ -2152,6 +2297,13 @@ rs6000_init_hard_regno_mode_ok (bool global_init_p) { rs6000_vector_reload[DFmode][0] = CODE_FOR_reload_df_si_store; rs6000_vector_reload[DFmode][1] = CODE_FOR_reload_df_si_load; + rs6000_vector_reload[DDmode][0] = CODE_FOR_reload_dd_si_store; + rs6000_vector_reload[DDmode][1] = CODE_FOR_reload_dd_si_load; + } + if (TARGET_VSX_TIMODE) + { + rs6000_vector_reload[TImode][0] = CODE_FOR_reload_ti_si_store; + rs6000_vector_reload[TImode][1] = CODE_FOR_reload_ti_si_load; } } } @@ -2641,6 +2793,9 @@ rs6000_option_override_internal (bool global_init_p) } } + if (TARGET_DEBUG_REG || TARGET_DEBUG_TARGET) + rs6000_print_isa_options (stderr, 0, "before defaults", rs6000_isa_flags); + /* For the newer switches (vsx, dfp, etc.) set some of the older options, unless the user explicitly used the -mno-<option> to disable the code. */ if (TARGET_VSX) @@ -2658,6 +2813,16 @@ rs6000_option_override_internal (bool global_init_p) else if (TARGET_ALTIVEC) rs6000_isa_flags |= (OPTION_MASK_PPC_GFXOPT & ~rs6000_isa_flags_explicit); + if (TARGET_VSX_TIMODE && !TARGET_VSX) + { + if (rs6000_isa_flags_explicit & OPTION_MASK_VSX_TIMODE) + error ("-mvsx-timode requires -mvsx"); + rs6000_isa_flags &= ~OPTION_MASK_VSX_TIMODE; + } + + if (TARGET_DEBUG_REG || TARGET_DEBUG_TARGET) + rs6000_print_isa_options (stderr, 0, "after defaults", rs6000_isa_flags); + /* E500mc does "better" if we inline more aggressively. Respect the user's opinion, though. */ if (rs6000_block_move_inline_limit == 0 @@ -2784,6 +2949,9 @@ rs6000_option_override_internal (bool global_init_p) if (flag_section_anchors) TARGET_NO_FP_IN_TOC = 1; + if (TARGET_DEBUG_REG || TARGET_DEBUG_TARGET) + rs6000_print_isa_options (stderr, 0, "before subtarget", rs6000_isa_flags); + #ifdef SUBTARGET_OVERRIDE_OPTIONS SUBTARGET_OVERRIDE_OPTIONS; #endif @@ -2794,6 +2962,9 @@ rs6000_option_override_internal (bool global_init_p) SUB3TARGET_OVERRIDE_OPTIONS; #endif + if (TARGET_DEBUG_REG || TARGET_DEBUG_TARGET) + rs6000_print_isa_options (stderr, 0, "after subtarget", rs6000_isa_flags); + /* For the E500 family of cores, reset the single/double FP flags to let us check that they remain constant across attributes or pragmas. Also, clear a possible request for string instructions, not supported and which @@ -4932,7 +5103,7 @@ invalid_e500_subreg (rtx op, enum machine_mode mode) purpose. */ if (GET_CODE (op) == SUBREG && (mode == SImode || mode == DImode || mode == TImode - || mode == DDmode || mode == TDmode) + || mode == DDmode || mode == TDmode || mode == PTImode) && REG_P (SUBREG_REG (op)) && (GET_MODE (SUBREG_REG (op)) == DFmode || GET_MODE (SUBREG_REG (op)) == TFmode)) @@ -4945,6 +5116,7 @@ invalid_e500_subreg (rtx op, enum machine_mode mode) && REG_P (SUBREG_REG (op)) && (GET_MODE (SUBREG_REG (op)) == DImode || GET_MODE (SUBREG_REG (op)) == TImode + || GET_MODE (SUBREG_REG (op)) == PTImode || GET_MODE (SUBREG_REG (op)) == DDmode || GET_MODE (SUBREG_REG (op)) == TDmode)) return true; @@ -5164,7 +5336,11 @@ reg_offset_addressing_ok_p (enum machine_mode mode) case V4SImode: case V2DFmode: case V2DImode: - /* AltiVec/VSX vector modes. Only reg+reg addressing is valid. */ + case TImode: + /* AltiVec/VSX vector modes. Only reg+reg addressing is valid. While + TImode is not a vector mode, if we want to use the VSX registers to + move it around, we need to restrict ourselves to reg+reg + addressing. */ if (VECTOR_MEM_ALTIVEC_OR_VSX_P (mode)) return false; break; @@ -5178,6 +5354,13 @@ reg_offset_addressing_ok_p (enum machine_mode mode) return false; break; + case SDmode: + /* If we can do direct load/stores of SDmode, restrict it to reg+reg + addressing for the LFIWZX and STFIWX instructions. */ + if (TARGET_NO_SDMODE_STACK) + return false; + break; + default: break; } @@ -5410,7 +5593,7 @@ rs6000_legitimate_offset_address_p (enum machine_mode mode, rtx x, /* If we are using VSX scalar loads, restrict ourselves to reg+reg addressing. */ - if (mode == DFmode && VECTOR_MEM_VSX_P (DFmode)) + if (VECTOR_MEM_VSX_P (mode)) return false; if (!worst_case) @@ -5424,6 +5607,7 @@ rs6000_legitimate_offset_address_p (enum machine_mode mode, rtx x, case TFmode: case TDmode: case TImode: + case PTImode: if (TARGET_E500_DOUBLE) return (SPE_CONST_OFFSET_OK (offset) && SPE_CONST_OFFSET_OK (offset + 8)); @@ -5597,11 +5781,12 @@ rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, case TFmode: case TDmode: case TImode: + case PTImode: /* As in legitimate_offset_address_p we do not assume worst-case. The mode here is just a hint as to the registers used. A TImode is usually in gprs, but may actually be in fprs. Leave worst-case scenario for reload to handle via - insn constraints. */ + insn constraints. PTImode is only GPRs. */ extra = 8; break; default: @@ -6332,7 +6517,7 @@ rs6000_legitimize_reload_address (rtx x, enum machine_mode mode, && !(TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode || mode == DDmode || mode == TDmode || mode == DImode)) - && VECTOR_MEM_NONE_P (mode)) + && (!VECTOR_MODE_P (mode) || VECTOR_MEM_NONE_P (mode))) { HOST_WIDE_INT val = INTVAL (XEXP (x, 1)); HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000; @@ -6363,7 +6548,7 @@ rs6000_legitimize_reload_address (rtx x, enum machine_mode mode, if (GET_CODE (x) == SYMBOL_REF && reg_offset_p - && VECTOR_MEM_NONE_P (mode) + && (!VECTOR_MODE_P (mode) || VECTOR_MEM_NONE_P (mode)) && !SPE_VECTOR_MODE (mode) #if TARGET_MACHO && DEFAULT_ABI == ABI_DARWIN @@ -6389,6 +6574,8 @@ rs6000_legitimize_reload_address (rtx x, enum machine_mode mode, mem is sufficiently aligned. */ && mode != TFmode && mode != TDmode + && (mode != TImode || !TARGET_VSX_TIMODE) + && mode != PTImode && (mode != DImode || TARGET_POWERPC64) && ((mode != DFmode && mode != DDmode) || TARGET_POWERPC64 || (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT))) @@ -6510,10 +6697,12 @@ rs6000_legitimate_address_p (enum machine_mode mode, rtx x, bool reg_ok_strict) if (legitimate_indirect_address_p (x, reg_ok_strict)) return 1; if ((GET_CODE (x) == PRE_INC || GET_CODE (x) == PRE_DEC) - && !VECTOR_MEM_ALTIVEC_OR_VSX_P (mode) + && !ALTIVEC_OR_VSX_VECTOR_MODE (mode) && !SPE_VECTOR_MODE (mode) && mode != TFmode && mode != TDmode + && mode != TImode + && mode != PTImode /* Restrict addressing for DI because of our SUBREG hackery. */ && !(TARGET_E500_DOUBLE && (mode == DFmode || mode == DDmode || mode == DImode)) @@ -6538,26 +6727,28 @@ rs6000_legitimate_address_p (enum machine_mode mode, rtx x, bool reg_ok_strict) return 1; if (rs6000_legitimate_offset_address_p (mode, x, reg_ok_strict, false)) return 1; - if (mode != TImode - && mode != TFmode + if (mode != TFmode && mode != TDmode && ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_POWERPC64 || (mode != DFmode && mode != DDmode) || (TARGET_E500_DOUBLE && mode != DDmode)) && (TARGET_POWERPC64 || mode != DImode) + && (mode != TImode || VECTOR_MEM_VSX_P (TImode)) + && mode != PTImode && !avoiding_indexed_address_p (mode) && legitimate_indexed_address_p (x, reg_ok_strict)) return 1; if (GET_CODE (x) == PRE_MODIFY && mode != TImode + && mode != PTImode && mode != TFmode && mode != TDmode && ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT) || TARGET_POWERPC64 || ((mode != DFmode && mode != DDmode) || TARGET_E500_DOUBLE)) && (TARGET_POWERPC64 || mode != DImode) - && !VECTOR_MEM_ALTIVEC_OR_VSX_P (mode) + && !ALTIVEC_OR_VSX_VECTOR_MODE (mode) && !SPE_VECTOR_MODE (mode) /* Restrict addressing for DI because of our SUBREG hackery. */ && !(TARGET_E500_DOUBLE @@ -7000,7 +7191,7 @@ rs6000_emit_set_long_const (rtx dest, HOST_WIDE_INT c1, HOST_WIDE_INT c2) } /* Helper for the following. Get rid of [r+r] memory refs - in cases where it won't work (TImode, TFmode, TDmode). */ + in cases where it won't work (TImode, TFmode, TDmode, PTImode). */ static void rs6000_eliminate_indexed_memrefs (rtx operands[2]) @@ -7145,6 +7336,7 @@ rs6000_emit_move (rtx dest, rtx source, enum machine_mode mode) if (reload_in_progress && mode == SDmode + && cfun->machine->sdmode_stack_slot != NULL_RTX && MEM_P (operands[0]) && rtx_equal_p (operands[0], cfun->machine->sdmode_stack_slot) && REG_P (operands[1])) @@ -7169,6 +7361,7 @@ rs6000_emit_move (rtx dest, rtx source, enum machine_mode mode) && mode == SDmode && REG_P (operands[0]) && MEM_P (operands[1]) + && cfun->machine->sdmode_stack_slot != NULL_RTX && rtx_equal_p (operands[1], cfun->machine->sdmode_stack_slot)) { if (FP_REGNO_P (REGNO (operands[0]))) @@ -7382,6 +7575,11 @@ rs6000_emit_move (rtx dest, rtx source, enum machine_mode mode) break; case TImode: + if (!VECTOR_MEM_VSX_P (TImode)) + rs6000_eliminate_indexed_memrefs (operands); + break; + + case PTImode: rs6000_eliminate_indexed_memrefs (operands); break; @@ -13624,7 +13822,7 @@ rs6000_secondary_memory_needed_rtx (enum machine_mode mode) static bool eliminated = false; rtx ret; - if (mode != SDmode) + if (mode != SDmode || TARGET_NO_SDMODE_STACK) ret = assign_stack_local (mode, GET_MODE_SIZE (mode), 0); else { @@ -13751,7 +13949,7 @@ rs6000_secondary_reload (bool in_p, if (rclass == GENERAL_REGS || rclass == BASE_REGS) { if (!legitimate_indirect_address_p (addr, false) - && !rs6000_legitimate_offset_address_p (TImode, addr, + && !rs6000_legitimate_offset_address_p (PTImode, addr, false, true)) { sri->icode = icode; @@ -13761,8 +13959,20 @@ rs6000_secondary_reload (bool in_p, + ((GET_CODE (addr) == AND) ? 1 : 0)); } } - /* Loads to and stores from vector registers can only do reg+reg - addressing. Altivec registers can also do (reg+reg)&(-16). */ + /* Allow scalar loads to/from the traditional floating point + registers, even if VSX memory is set. */ + else if ((rclass == FLOAT_REGS || rclass == NO_REGS) + && (GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8) + && (legitimate_indirect_address_p (addr, false) + || legitimate_indirect_address_p (XEXP (addr, 0), false) + || rs6000_legitimate_offset_address_p (mode, addr, + false, true))) + + ; + /* Loads to and stores from vector registers can only do reg+reg + addressing. Altivec registers can also do (reg+reg)&(-16). Allow + scalar modes loading up the traditional floating point registers + to use offset addresses. */ else if (rclass == VSX_REGS || rclass == ALTIVEC_REGS || rclass == FLOAT_REGS || rclass == NO_REGS) { @@ -13938,6 +14148,36 @@ rs6000_secondary_reload (bool in_p, return ret; } +/* Better tracing for rs6000_secondary_reload_inner. */ + +static void +rs6000_secondary_reload_trace (int line, rtx reg, rtx mem, rtx scratch, + bool store_p) +{ + rtx set, clobber; + + gcc_assert (reg != NULL_RTX && mem != NULL_RTX && scratch != NULL_RTX); + + fprintf (stderr, "rs6000_secondary_reload_inner:%d, type = %s\n", line, + store_p ? "store" : "load"); + + if (store_p) + set = gen_rtx_SET (VOIDmode, mem, reg); + else + set = gen_rtx_SET (VOIDmode, reg, mem); + + clobber = gen_rtx_CLOBBER (VOIDmode, scratch); + debug_rtx (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set, clobber))); +} + +static void +rs6000_secondary_reload_fail (int line, rtx reg, rtx mem, rtx scratch, + bool store_p) +{ + rs6000_secondary_reload_trace (line, reg, mem, scratch, store_p); + gcc_unreachable (); +} + /* Fixup reload addresses for Altivec or VSX loads/stores to change SP+offset to SP+reg addressing. */ @@ -13956,19 +14196,14 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p) rtx cc_clobber; if (TARGET_DEBUG_ADDR) - { - fprintf (stderr, "\nrs6000_secondary_reload_inner, type = %s\n", - store_p ? "store" : "load"); - fprintf (stderr, "reg:\n"); - debug_rtx (reg); - fprintf (stderr, "mem:\n"); - debug_rtx (mem); - fprintf (stderr, "scratch:\n"); - debug_rtx (scratch); - } + rs6000_secondary_reload_trace (__LINE__, reg, mem, scratch, store_p); + + if (regno < 0 || regno >= FIRST_PSEUDO_REGISTER) + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); + + if (GET_CODE (mem) != MEM) + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); - gcc_assert (regno >= 0 && regno < FIRST_PSEUDO_REGISTER); - gcc_assert (GET_CODE (mem) == MEM); rclass = REGNO_REG_CLASS (regno); addr = XEXP (mem, 0); @@ -13987,19 +14222,24 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p) if (GET_CODE (addr) == PRE_MODIFY) { scratch_or_premodify = XEXP (addr, 0); - gcc_assert (REG_P (scratch_or_premodify)); - gcc_assert (GET_CODE (XEXP (addr, 1)) == PLUS); + if (!REG_P (scratch_or_premodify)) + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); + + if (GET_CODE (XEXP (addr, 1)) != PLUS) + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); + addr = XEXP (addr, 1); } if (GET_CODE (addr) == PLUS && (and_op2 != NULL_RTX - || !rs6000_legitimate_offset_address_p (TImode, addr, + || !rs6000_legitimate_offset_address_p (PTImode, addr, false, true))) { addr_op1 = XEXP (addr, 0); addr_op2 = XEXP (addr, 1); - gcc_assert (legitimate_indirect_address_p (addr_op1, false)); + if (!legitimate_indirect_address_p (addr_op1, false)) + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); if (!REG_P (addr_op2) && (GET_CODE (addr_op2) != CONST_INT @@ -14027,7 +14267,7 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p) scratch_or_premodify = scratch; } else if (!legitimate_indirect_address_p (addr, false) - && !rs6000_legitimate_offset_address_p (TImode, addr, + && !rs6000_legitimate_offset_address_p (PTImode, addr, false, true)) { if (TARGET_DEBUG_ADDR) @@ -14043,9 +14283,21 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p) } break; - /* Float/Altivec registers can only handle reg+reg addressing. Move - other addresses into a scratch register. */ + /* Float registers can do offset+reg addressing for scalar types. */ case FLOAT_REGS: + if (legitimate_indirect_address_p (addr, false) /* reg */ + || legitimate_indexed_address_p (addr, false) /* reg+reg */ + || ((GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8) + && and_op2 == NULL_RTX + && scratch_or_premodify == scratch + && rs6000_legitimate_offset_address_p (mode, addr, false, false))) + break; + + /* If this isn't a legacy floating point load/store, fall through to the + VSX defaults. */ + + /* VSX/Altivec registers can only handle reg+reg addressing. Move other + addresses into a scratch register. */ case VSX_REGS: case ALTIVEC_REGS: @@ -14065,36 +14317,38 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p) /* If we aren't using a VSX load, save the PRE_MODIFY register and use it as the address later. */ if (GET_CODE (addr) == PRE_MODIFY - && (!VECTOR_MEM_VSX_P (mode) + && ((ALTIVEC_OR_VSX_VECTOR_MODE (mode) + && (rclass != FLOAT_REGS + || (GET_MODE_SIZE (mode) != 4 && GET_MODE_SIZE (mode) != 8))) || and_op2 != NULL_RTX || !legitimate_indexed_address_p (XEXP (addr, 1), false))) { scratch_or_premodify = XEXP (addr, 0); - gcc_assert (legitimate_indirect_address_p (scratch_or_premodify, - false)); - gcc_assert (GET_CODE (XEXP (addr, 1)) == PLUS); + if (!legitimate_indirect_address_p (scratch_or_premodify, false)) + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); + + if (GET_CODE (XEXP (addr, 1)) != PLUS) + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); + addr = XEXP (addr, 1); } if (legitimate_indirect_address_p (addr, false) /* reg */ || legitimate_indexed_address_p (addr, false) /* reg+reg */ - || GET_CODE (addr) == PRE_MODIFY /* VSX pre-modify */ || (GET_CODE (addr) == AND /* Altivec memory */ + && rclass == ALTIVEC_REGS && GET_CODE (XEXP (addr, 1)) == CONST_INT && INTVAL (XEXP (addr, 1)) == -16 - && VECTOR_MEM_ALTIVEC_P (mode)) - || (rclass == FLOAT_REGS /* legacy float mem */ - && GET_MODE_SIZE (mode) == 8 - && and_op2 == NULL_RTX - && scratch_or_premodify == scratch - && rs6000_legitimate_offset_address_p (mode, addr, false, false))) + && (legitimate_indirect_address_p (XEXP (addr, 0), false) + || legitimate_indexed_address_p (XEXP (addr, 0), false)))) ; else if (GET_CODE (addr) == PLUS) { addr_op1 = XEXP (addr, 0); addr_op2 = XEXP (addr, 1); - gcc_assert (REG_P (addr_op1)); + if (!REG_P (addr_op1)) + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); if (TARGET_DEBUG_ADDR) { @@ -14113,7 +14367,8 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p) } else if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == CONST - || GET_CODE (addr) == CONST_INT || REG_P (addr)) + || GET_CODE (addr) == CONST_INT || GET_CODE (addr) == LO_SUM + || REG_P (addr)) { if (TARGET_DEBUG_ADDR) { @@ -14129,12 +14384,12 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p) } else - gcc_unreachable (); + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); break; default: - gcc_unreachable (); + rs6000_secondary_reload_fail (__LINE__, reg, mem, scratch, store_p); } /* If the original address involved a pre-modify that we couldn't use the VSX @@ -14246,8 +14501,10 @@ rs6000_secondary_reload_gpr (rtx reg, rtx mem, rtx scratch, bool store_p) return; } -/* Allocate a 64-bit stack slot to be used for copying SDmode - values through if this function has any SDmode references. */ +/* Allocate a 64-bit stack slot to be used for copying SDmode values through if + this function has any SDmode references. If we are on a power7 or later, we + don't need the 64-bit stack slot since the LFIWZX and STIFWX instructions + can load/store the value. */ static void rs6000_alloc_sdmode_stack_slot (void) @@ -14258,6 +14515,9 @@ rs6000_alloc_sdmode_stack_slot (void) gcc_assert (cfun->machine->sdmode_stack_slot == NULL_RTX); + if (TARGET_NO_SDMODE_STACK) + return; + FOR_EACH_BB (bb) for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { @@ -14318,8 +14578,7 @@ rs6000_preferred_reload_class (rtx x, enum reg_class rclass) { enum machine_mode mode = GET_MODE (x); - if (VECTOR_UNIT_VSX_P (mode) - && x == CONST0_RTX (mode) && VSX_REG_CLASS_P (rclass)) + if (TARGET_VSX && x == CONST0_RTX (mode) && VSX_REG_CLASS_P (rclass)) return rclass; if (VECTOR_UNIT_ALTIVEC_OR_VSX_P (mode) @@ -14494,11 +14753,17 @@ rs6000_secondary_reload_class (enum reg_class rclass, enum machine_mode mode, return (mode != SDmode) ? NO_REGS : GENERAL_REGS; /* Memory, and FP/altivec registers can go into fp/altivec registers under - VSX. */ + VSX. However, for scalar variables, use the traditional floating point + registers so that we can use offset+register addressing. */ if (TARGET_VSX && (regno == -1 || VSX_REGNO_P (regno)) && VSX_REG_CLASS_P (rclass)) - return NO_REGS; + { + if (GET_MODE_SIZE (mode) < 16) + return FLOAT_REGS; + + return NO_REGS; + } /* Memory, and AltiVec registers can go into AltiVec registers. */ if ((regno == -1 || ALTIVEC_REGNO_P (regno)) @@ -14543,8 +14808,35 @@ rs6000_cannot_change_mode_class (enum machine_mode from, if (from_size != to_size) { enum reg_class xclass = (TARGET_VSX) ? VSX_REGS : FLOAT_REGS; - return ((from_size < 8 || to_size < 8 || TARGET_IEEEQUAD) - && reg_classes_intersect_p (xclass, rclass)); + + if (reg_classes_intersect_p (xclass, rclass)) + { + unsigned to_nregs = hard_regno_nregs[FIRST_FPR_REGNO][to]; + unsigned from_nregs = hard_regno_nregs[FIRST_FPR_REGNO][from]; + + /* Don't allow 64-bit types to overlap with 128-bit types that take a + single register under VSX because the scalar part of the register + is in the upper 64-bits, and not the lower 64-bits. Types like + TFmode/TDmode that take 2 scalar register can overlap. 128-bit + IEEE floating point can't overlap, and neither can small + values. */ + + if (TARGET_IEEEQUAD && (to == TFmode || from == TFmode)) + return true; + + if (from_size < 8 || to_size < 8) + return true; + + if (from_size == 8 && (8 * to_nregs) != to_size) + return true; + + if (to_size == 8 && (8 * from_nregs) != from_size) + return true; + + return false; + } + else + return false; } if (TARGET_E500_DOUBLE @@ -14558,9 +14850,18 @@ rs6000_cannot_change_mode_class (enum machine_mode from, /* Since the VSX register set includes traditional floating point registers and altivec registers, just check for the size being different instead of trying to check whether the modes are vector modes. Otherwise it won't - allow say DF and DI to change classes. */ + allow say DF and DI to change classes. For types like TFmode and TDmode + that take 2 64-bit registers, rather than a single 128-bit register, don't + allow subregs of those types to other 128 bit types. */ if (TARGET_VSX && VSX_REG_CLASS_P (rclass)) - return (from_size != 8 && from_size != 16); + { + unsigned num_regs = (from_size + 15) / 16; + if (hard_regno_nregs[FIRST_FPR_REGNO][to] > num_regs + || hard_regno_nregs[FIRST_FPR_REGNO][from] > num_regs) + return true; + + return (from_size != 8 && from_size != 16); + } if (TARGET_ALTIVEC && rclass == ALTIVEC_REGS && (ALTIVEC_VECTOR_MODE (from) + ALTIVEC_VECTOR_MODE (to)) == 1) @@ -15295,7 +15596,7 @@ print_operand (FILE *file, rtx x, int code) return; case 'Y': - /* Like 'L', for third word of TImode */ + /* Like 'L', for third word of TImode/PTImode */ if (REG_P (x)) fputs (reg_names[REGNO (x) + 2], file); else if (MEM_P (x)) @@ -15345,7 +15646,7 @@ print_operand (FILE *file, rtx x, int code) return; case 'Z': - /* Like 'L', for last word of TImode. */ + /* Like 'L', for last word of TImode/PTImode. */ if (REG_P (x)) fputs (reg_names[REGNO (x) + 3], file); else if (MEM_P (x)) @@ -15376,7 +15677,8 @@ print_operand (FILE *file, rtx x, int code) if ((TARGET_SPE || TARGET_E500_DOUBLE) && (GET_MODE_SIZE (GET_MODE (x)) == 8 || GET_MODE (x) == TFmode - || GET_MODE (x) == TImode)) + || GET_MODE (x) == TImode + || GET_MODE (x) == PTImode)) { /* Handle [reg]. */ if (REG_P (tmp)) @@ -17541,9 +17843,8 @@ compute_save_world_info (rs6000_stack_t *info_ptr) if (WORLD_SAVE_P (info_ptr)) { rtx insn; - for ( insn = get_last_insn_anywhere (); insn; insn = PREV_INSN (insn)) - if ( GET_CODE (insn) == CALL_INSN - && SIBLING_CALL_P (insn)) + for (insn = get_last_insn_anywhere (); insn; insn = PREV_INSN (insn)) + if (CALL_P (insn) && SIBLING_CALL_P (insn)) { info_ptr->world_save_p = 0; break; @@ -23535,7 +23836,7 @@ is_load_insn (rtx insn, rtx *load_mem) if (!insn || !INSN_P (insn)) return false; - if (GET_CODE (insn) == CALL_INSN) + if (CALL_P (insn)) return false; return is_load_insn1 (PATTERN (insn), load_mem); @@ -23930,7 +24231,7 @@ insn_must_be_first_in_group (rtx insn) enum attr_type type; if (!insn - || GET_CODE (insn) == NOTE + || NOTE_P (insn) || DEBUG_INSN_P (insn) || GET_CODE (PATTERN (insn)) == USE || GET_CODE (PATTERN (insn)) == CLOBBER) @@ -24061,7 +24362,7 @@ insn_must_be_last_in_group (rtx insn) enum attr_type type; if (!insn - || GET_CODE (insn) == NOTE + || NOTE_P (insn) || DEBUG_INSN_P (insn) || GET_CODE (PATTERN (insn)) == USE || GET_CODE (PATTERN (insn)) == CLOBBER) @@ -26429,7 +26730,7 @@ rs6000_register_move_cost (enum machine_mode mode, } /* If we have VSX, we can easily move between FPR or Altivec registers. */ - else if (VECTOR_UNIT_VSX_P (mode) + else if (VECTOR_MEM_VSX_P (mode) && reg_classes_intersect_p (to, VSX_REGS) && reg_classes_intersect_p (from, VSX_REGS)) ret = 2 * hard_regno_nregs[32][mode]; @@ -26470,7 +26771,8 @@ rs6000_memory_move_cost (enum machine_mode mode, reg_class_t rclass, if (reg_classes_intersect_p (rclass, GENERAL_REGS)) ret = 4 * hard_regno_nregs[0][mode]; - else if (reg_classes_intersect_p (rclass, FLOAT_REGS)) + else if ((reg_classes_intersect_p (rclass, FLOAT_REGS) + || reg_classes_intersect_p (rclass, VSX_REGS))) ret = 4 * hard_regno_nregs[32][mode]; else if (reg_classes_intersect_p (rclass, ALTIVEC_REGS)) ret = 4 * hard_regno_nregs[FIRST_ALTIVEC_REGNO][mode]; @@ -27684,6 +27986,7 @@ static struct rs6000_opt_mask const rs6000_opt_masks[] = { "recip-precision", OPTION_MASK_RECIP_PRECISION, false, true }, { "string", OPTION_MASK_STRING, false, true }, { "vsx", OPTION_MASK_VSX, false, true }, + { "vsx-timode", OPTION_MASK_VSX_TIMODE, false, true }, #ifdef OPTION_MASK_64BIT #if TARGET_AIX_OS { "aix64", OPTION_MASK_64BIT, false, false }, diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h index b5c79ea6e95..b7b415d69c0 100644 --- a/gcc/config/rs6000/rs6000.h +++ b/gcc/config/rs6000/rs6000.h @@ -479,6 +479,11 @@ extern int rs6000_vector_align[]; #define TARGET_FCTIDUZ TARGET_POPCNTD #define TARGET_FCTIWUZ TARGET_POPCNTD +/* Power7 has both 32-bit load and store integer for the FPRs, so we don't need + to allocate the SDmode stack slot to get the value into the proper location + in the register. */ +#define TARGET_NO_SDMODE_STACK (TARGET_LFIWZX && TARGET_STFIWX && TARGET_DFP) + /* In switching from using target_flags to using rs6000_isa_flags, the options machinery creates OPTION_MASK_<xxx> instead of MASK_<xxx>. For now map OPTION_MASK_<xxx> back into MASK_<xxx>. */ @@ -505,6 +510,7 @@ extern int rs6000_vector_align[]; #define MASK_STRING OPTION_MASK_STRING #define MASK_UPDATE OPTION_MASK_UPDATE #define MASK_VSX OPTION_MASK_VSX +#define MASK_VSX_TIMODE OPTION_MASK_VSX_TIMODE #ifndef IN_LIBGCC2 #define MASK_POWERPC64 OPTION_MASK_POWERPC64 @@ -1325,8 +1331,13 @@ enum r6000_reg_class_enum { RS6000_CONSTRAINT_v, /* Altivec registers */ RS6000_CONSTRAINT_wa, /* Any VSX register */ RS6000_CONSTRAINT_wd, /* VSX register for V2DF */ + RS6000_CONSTRAINT_wg, /* FPR register for -mmfpgpr */ RS6000_CONSTRAINT_wf, /* VSX register for V4SF */ + RS6000_CONSTRAINT_wl, /* FPR register for LFIWAX */ RS6000_CONSTRAINT_ws, /* VSX register for DF */ + RS6000_CONSTRAINT_wt, /* VSX register for TImode */ + RS6000_CONSTRAINT_wx, /* FPR register for STFIWX */ + RS6000_CONSTRAINT_wz, /* FPR register for LFIWZX */ RS6000_CONSTRAINT_MAX }; @@ -1511,7 +1522,7 @@ extern enum reg_class rs6000_constraints[RS6000_CONSTRAINT_MAX]; NONLOCAL needs twice Pmode to maintain both backchain and SP. */ #define STACK_SAVEAREA_MODE(LEVEL) \ (LEVEL == SAVE_FUNCTION ? VOIDmode \ - : LEVEL == SAVE_NONLOCAL ? (TARGET_32BIT ? DImode : TImode) : Pmode) + : LEVEL == SAVE_NONLOCAL ? (TARGET_32BIT ? DImode : PTImode) : Pmode) /* Minimum and maximum general purpose registers used to hold arguments. */ #define GP_ARG_MIN_REG 3 diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md index a665fa50abf..0a5d32728a1 100644 --- a/gcc/config/rs6000/rs6000.md +++ b/gcc/config/rs6000/rs6000.md @@ -25,10 +25,14 @@ ;; (define_constants - [(STACK_POINTER_REGNUM 1) + [(FIRST_GPR_REGNO 0) + (STACK_POINTER_REGNUM 1) (TOC_REGNUM 2) (STATIC_CHAIN_REGNUM 11) (HARD_FRAME_POINTER_REGNUM 31) + (LAST_GPR_REGNO 31) + (FIRST_FPR_REGNO 32) + (LAST_FPR_REGNO 63) (LR_REGNO 65) (CTR_REGNO 66) (ARG_POINTER_REGNUM 67) @@ -215,7 +219,7 @@ (define_mode_iterator GPR [SI (DI "TARGET_POWERPC64")]) ; Any supported integer mode. -(define_mode_iterator INT [QI HI SI DI TI]) +(define_mode_iterator INT [QI HI SI DI TI PTI]) ; Any supported integer mode that fits in one register. (define_mode_iterator INT1 [QI HI SI (DI "TARGET_POWERPC64")]) @@ -230,6 +234,10 @@ ; (one with a '.') will compare; and the size used for arithmetic carries. (define_mode_iterator P [(SI "TARGET_32BIT") (DI "TARGET_64BIT")]) +; Iterator to add PTImode along with TImode (TImode can go in VSX registers, +; PTImode is GPR only) +(define_mode_iterator TI2 [TI PTI]) + ; Any hardware-supported floating-point mode (define_mode_iterator FP [ (SF "TARGET_HARD_FLOAT @@ -253,6 +261,35 @@ (V2DF "VECTOR_UNIT_ALTIVEC_OR_VSX_P (V2DFmode)") ]) +; Floating point move iterators to combine binary and decimal moves +(define_mode_iterator FMOVE32 [SF SD]) +(define_mode_iterator FMOVE64 [DF DD]) +(define_mode_iterator FMOVE64X [DI DF DD]) +(define_mode_iterator FMOVE128 [(TF "!TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128") + (TD "TARGET_HARD_FLOAT && TARGET_FPRS")]) + +; Whether a floating point move is ok, don't allow SD without hardware FP +(define_mode_attr fmove_ok [(SF "") + (DF "") + (SD "TARGET_HARD_FLOAT && TARGET_FPRS") + (DD "")]) + +; Convert REAL_VALUE to the appropriate bits +(define_mode_attr real_value_to_target [(SF "REAL_VALUE_TO_TARGET_SINGLE") + (DF "REAL_VALUE_TO_TARGET_DOUBLE") + (SD "REAL_VALUE_TO_TARGET_DECIMAL32") + (DD "REAL_VALUE_TO_TARGET_DECIMAL64")]) + +; Definitions for load to 32-bit fpr register +(define_mode_attr f32_lr [(SF "f") (SD "wz")]) +(define_mode_attr f32_lm [(SF "m") (SD "Z")]) +(define_mode_attr f32_li [(SF "lfs%U1%X1 %0,%1") (SD "lfiwzx %0,%y1")]) + +; Definitions for store from 32-bit fpr register +(define_mode_attr f32_sr [(SF "f") (SD "wx")]) +(define_mode_attr f32_sm [(SF "m") (SD "Z")]) +(define_mode_attr f32_si [(SF "stfs%U0%X0 %1,%0") (SD "stfiwx %1,%y0")]) + ; These modes do not fit in integer registers in 32-bit mode. ; but on e500v2, the gpr are 64 bit registers (define_mode_iterator DIFD [DI (DF "!TARGET_E500_DOUBLE") DD]) @@ -271,7 +308,14 @@ ; Various instructions that come in SI and DI forms. ; A generic w/d attribute, for things like cmpw/cmpd. -(define_mode_attr wd [(QI "b") (HI "h") (SI "w") (DI "d")]) +(define_mode_attr wd [(QI "b") + (HI "h") + (SI "w") + (DI "d") + (V16QI "b") + (V8HI "h") + (V4SI "w") + (V2DI "d")]) ; DImode bits (define_mode_attr dbits [(QI "56") (HI "48") (SI "32")]) @@ -328,7 +372,15 @@ "@ l<wd>z%U1%X1 %0,%1 rldicl %0,%1,0,<dbits>" - [(set_attr "type" "load,*")]) + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (const_string "*")])]) (define_insn "*zero_extend<mode>di2_internal2" [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y") @@ -454,7 +506,15 @@ "@ lha%U1%X1 %0,%1 extsh %0,%1" - [(set_attr "type" "load_ext,exts")]) + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ext_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_ext_u") + (const_string "load_ext"))) + (const_string "exts")])]) (define_insn "" [(set (match_operand:DI 0 "gpc_reg_operand" "=r") @@ -528,7 +588,15 @@ "@ lwa%U1%X1 %0,%1 extsw %0,%1" - [(set_attr "type" "load_ext,exts")]) + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ext_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_ext_u") + (const_string "load_ext"))) + (const_string "exts")])]) (define_insn "" [(set (match_operand:DI 0 "gpc_reg_operand" "=r") @@ -602,7 +670,15 @@ "@ lbz%U1%X1 %0,%1 rlwinm %0,%1,0,0xff" - [(set_attr "type" "load,*")]) + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (const_string "*")])]) (define_insn "" [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y") @@ -722,7 +798,15 @@ "@ lbz%U1%X1 %0,%1 rlwinm %0,%1,0,0xff" - [(set_attr "type" "load,*")]) + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (const_string "*")])]) (define_insn "" [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y") @@ -848,7 +932,15 @@ "@ lhz%U1%X1 %0,%1 rlwinm %0,%1,0,0xffff" - [(set_attr "type" "load,*")]) + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (const_string "*")])]) (define_insn "" [(set (match_operand:CC 0 "cc_reg_operand" "=x,?y") @@ -915,7 +1007,15 @@ "@ lha%U1%X1 %0,%1 extsh %0,%1" - [(set_attr "type" "load_ext,exts")]) + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ext_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_ext_u") + (const_string "load_ext"))) + (const_string "exts")])]) (define_insn "" [(set (match_operand:SI 0 "gpc_reg_operand" "=r") @@ -4498,7 +4598,16 @@ emit_note (NOTE_INSN_DELETED); DONE; } - [(set_attr "type" "fp,fp,fpload")]) + [(set_attr_alternative "type" + [(const_string "fp") + (const_string "fp") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "fpload_u") + (const_string "fpload")))])]) (define_expand "truncdfsf2" [(set (match_operand:SF 0 "gpc_reg_operand" "") @@ -7723,7 +7832,31 @@ mt%0 %1 mt%0 %1 nop" - [(set_attr "type" "*,*,load,store,*,*,*,mfjmpr,mtjmpr,*,*") + [(set_attr_alternative "type" + [(const_string "*") + (const_string "*") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (const_string "*") + (const_string "*") + (const_string "*") + (const_string "mfjmpr") + (const_string "mtjmpr") + (const_string "*") + (const_string "*")]) + (set_attr "length" "4,4,4,4,4,4,8,4,4,4,4")]) (define_insn "*movsi_internal1_single" @@ -7745,7 +7878,44 @@ nop stfs%U0%X0 %1,%0 lfs%U1%X1 %0,%1" - [(set_attr "type" "*,*,load,store,*,*,*,mfjmpr,mtjmpr,*,*,*,*") + [(set_attr_alternative "type" + [(const_string "*") + (const_string "*") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (const_string "*") + (const_string "*") + (const_string "*") + (const_string "mfjmpr") + (const_string "mtjmpr") + (const_string "*") + (const_string "*") + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_u") + (const_string "fpstore"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "fpload_u") + (const_string "fpload")))]) (set_attr "length" "4,4,4,4,4,4,8,4,4,4,4,4,4")]) ;; Split a load of a large constant into the appropriate two-insn @@ -7808,7 +7978,26 @@ mf%1 %0 mt%0 %1 nop" - [(set_attr "type" "*,load,store,*,mfjmpr,mtjmpr,*")]) + [(set_attr_alternative "type" + [(const_string "*") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (const_string "*") + (const_string "mfjmpr") + (const_string "mtjmpr") + (const_string "*")])]) (define_expand "mov<mode>" [(set (match_operand:INT 0 "general_operand" "") @@ -7829,7 +8018,26 @@ mf%1 %0 mt%0 %1 nop" - [(set_attr "type" "*,load,store,*,mfjmpr,mtjmpr,*")]) + [(set_attr_alternative "type" + [(const_string "*") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (const_string "*") + (const_string "mfjmpr") + (const_string "mtjmpr") + (const_string "*")])]) ;; Here is how to move condition codes around. When we store CC data in ;; an integer register or memory, we store just the high-order 4 bits. @@ -7857,7 +8065,7 @@ mf%1 %0 mt%0 %1 lwz%U1%X1 %0,%1 - stw%U0%U1 %1,%0" + stw%U0%X0 %1,%0" [(set (attr "type") (cond [(eq_attr "alternative" "0,3") (const_string "cr_logical") @@ -7870,9 +8078,23 @@ (eq_attr "alternative" "9") (const_string "mtjmpr") (eq_attr "alternative" "10") - (const_string "load") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], + VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) (eq_attr "alternative" "11") - (const_string "store") + (if_then_else + (match_test "update_indexed_address_mem (operands[0], + VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) (match_test "TARGET_MFCRF") (const_string "mfcrf") ] @@ -7884,15 +8106,17 @@ ;; can produce floating-point values in fixed-point registers. Unless the ;; value is a simple constant or already in memory, we deal with this by ;; allocating memory and copying the value explicitly via that memory location. -(define_expand "movsf" - [(set (match_operand:SF 0 "nonimmediate_operand" "") - (match_operand:SF 1 "any_operand" ""))] - "" - "{ rs6000_emit_move (operands[0], operands[1], SFmode); DONE; }") + +;; Move 32-bit binary/decimal floating point +(define_expand "mov<mode>" + [(set (match_operand:FMOVE32 0 "nonimmediate_operand" "") + (match_operand:FMOVE32 1 "any_operand" ""))] + "<fmove_ok>" + "{ rs6000_emit_move (operands[0], operands[1], <MODE>mode); DONE; }") (define_split - [(set (match_operand:SF 0 "gpc_reg_operand" "") - (match_operand:SF 1 "const_double_operand" ""))] + [(set (match_operand:FMOVE32 0 "gpc_reg_operand" "") + (match_operand:FMOVE32 1 "const_double_operand" ""))] "reload_completed && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31) || (GET_CODE (operands[0]) == SUBREG @@ -7905,42 +8129,81 @@ REAL_VALUE_TYPE rv; REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]); - REAL_VALUE_TO_TARGET_SINGLE (rv, l); + <real_value_to_target> (rv, l); if (! TARGET_POWERPC64) - operands[2] = operand_subword (operands[0], 0, 0, SFmode); + operands[2] = operand_subword (operands[0], 0, 0, <MODE>mode); else operands[2] = gen_lowpart (SImode, operands[0]); operands[3] = gen_int_mode (l, SImode); }") -(define_insn "*movsf_hardfloat" - [(set (match_operand:SF 0 "nonimmediate_operand" "=!r,!r,m,f,f,m,*c*l,!r,*h,!r,!r") - (match_operand:SF 1 "input_operand" "r,m,r,f,m,f,r,h,0,G,Fn"))] - "(gpc_reg_operand (operands[0], SFmode) - || gpc_reg_operand (operands[1], SFmode)) +(define_insn "mov<mode>_hardfloat" + [(set (match_operand:FMOVE32 0 "nonimmediate_operand" "=!r,!r,m,f,wa,wa,<f32_lr>,<f32_sm>,*c*l,!r,*h,!r,!r") + (match_operand:FMOVE32 1 "input_operand" "r,m,r,f,wa,j,<f32_lm>,<f32_sr>,r,h,0,G,Fn"))] + "(gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode)) && (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT)" "@ mr %0,%1 lwz%U1%X1 %0,%1 stw%U0%X0 %1,%0 fmr %0,%1 - lfs%U1%X1 %0,%1 - stfs%U0%X0 %1,%0 + xxlor %x0,%x1,%x1 + xxlxor %x0,%x0,%x0 + <f32_li> + <f32_si> mt%0 %1 mf%1 %0 nop # #" - [(set_attr "type" "*,load,store,fp,fpload,fpstore,mtjmpr,mfjmpr,*,*,*") - (set_attr "length" "4,4,4,4,4,4,4,4,4,4,8")]) - -(define_insn "*movsf_softfloat" - [(set (match_operand:SF 0 "nonimmediate_operand" "=r,cl,r,r,m,r,r,r,r,*h") - (match_operand:SF 1 "input_operand" "r,r,h,m,r,I,L,G,Fn,0"))] - "(gpc_reg_operand (operands[0], SFmode) - || gpc_reg_operand (operands[1], SFmode)) + [(set_attr_alternative "type" + [(const_string "*") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (const_string "fp") + (const_string "vecsimple") + (const_string "vecsimple") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "fpload_u") + (const_string "fpload"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_u") + (const_string "fpstore"))) + (const_string "mtjmpr") + (const_string "mfjmpr") + (const_string "*") + (const_string "*") + (const_string "*")]) + (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4,8")]) + +(define_insn "*mov<mode>_softfloat" + [(set (match_operand:FMOVE32 0 "nonimmediate_operand" "=r,cl,r,r,m,r,r,r,r,*h") + (match_operand:FMOVE32 1 "input_operand" "r, r,h,m,r,I,L,G,Fn,0"))] + "(gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode)) && (TARGET_SOFT_FLOAT || !TARGET_FPRS)" "@ mr %0,%1 @@ -7953,19 +8216,42 @@ # # nop" - [(set_attr "type" "*,mtjmpr,mfjmpr,load,store,*,*,*,*,*") + [(set_attr_alternative "type" + [(const_string "*") + (const_string "mtjmpr") + (const_string "mfjmpr") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (const_string "*") + (const_string "*") + (const_string "*") + (const_string "*") + (const_string "*")]) (set_attr "length" "4,4,4,4,4,4,4,4,8,4")]) -(define_expand "movdf" - [(set (match_operand:DF 0 "nonimmediate_operand" "") - (match_operand:DF 1 "any_operand" ""))] +;; Move 64-bit binary/decimal floating point +(define_expand "mov<mode>" + [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "") + (match_operand:FMOVE64 1 "any_operand" ""))] "" - "{ rs6000_emit_move (operands[0], operands[1], DFmode); DONE; }") + "{ rs6000_emit_move (operands[0], operands[1], <MODE>mode); DONE; }") (define_split - [(set (match_operand:DF 0 "gpc_reg_operand" "") - (match_operand:DF 1 "const_int_operand" ""))] + [(set (match_operand:FMOVE64 0 "gpc_reg_operand" "") + (match_operand:FMOVE64 1 "const_int_operand" ""))] "! TARGET_POWERPC64 && reload_completed && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31) || (GET_CODE (operands[0]) == SUBREG @@ -7978,8 +8264,8 @@ int endian = (WORDS_BIG_ENDIAN == 0); HOST_WIDE_INT value = INTVAL (operands[1]); - operands[2] = operand_subword (operands[0], endian, 0, DFmode); - operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode); + operands[2] = operand_subword (operands[0], endian, 0, <MODE>mode); + operands[3] = operand_subword (operands[0], 1 - endian, 0, <MODE>mode); #if HOST_BITS_PER_WIDE_INT == 32 operands[4] = (value & 0x80000000) ? constm1_rtx : const0_rtx; #else @@ -7989,8 +8275,8 @@ }") (define_split - [(set (match_operand:DF 0 "gpc_reg_operand" "") - (match_operand:DF 1 "const_double_operand" ""))] + [(set (match_operand:FMOVE64 0 "gpc_reg_operand" "") + (match_operand:FMOVE64 1 "const_double_operand" ""))] "! TARGET_POWERPC64 && reload_completed && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31) || (GET_CODE (operands[0]) == SUBREG @@ -8005,17 +8291,17 @@ REAL_VALUE_TYPE rv; REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]); - REAL_VALUE_TO_TARGET_DOUBLE (rv, l); + <real_value_to_target> (rv, l); - operands[2] = operand_subword (operands[0], endian, 0, DFmode); - operands[3] = operand_subword (operands[0], 1 - endian, 0, DFmode); + operands[2] = operand_subword (operands[0], endian, 0, <MODE>mode); + operands[3] = operand_subword (operands[0], 1 - endian, 0, <MODE>mode); operands[4] = gen_int_mode (l[endian], SImode); operands[5] = gen_int_mode (l[1 - endian], SImode); }") (define_split - [(set (match_operand:DF 0 "gpc_reg_operand" "") - (match_operand:DF 1 "const_double_operand" ""))] + [(set (match_operand:FMOVE64 0 "gpc_reg_operand" "") + (match_operand:FMOVE64 1 "const_double_operand" ""))] "TARGET_POWERPC64 && reload_completed && ((GET_CODE (operands[0]) == REG && REGNO (operands[0]) <= 31) || (GET_CODE (operands[0]) == SUBREG @@ -8032,7 +8318,7 @@ #endif REAL_VALUE_FROM_CONST_DOUBLE (rv, operands[1]); - REAL_VALUE_TO_TARGET_DOUBLE (rv, l); + <real_value_to_target> (rv, l); operands[2] = gen_lowpart (DImode, operands[0]); /* HIGHPART is lower memory address when WORDS_BIG_ENDIAN. */ @@ -8057,12 +8343,12 @@ ;; since the D-form version of the memory instructions does not need a GPR for ;; reloading. -(define_insn "*movdf_hardfloat32" - [(set (match_operand:DF 0 "nonimmediate_operand" "=m,d,d,ws,?wa,Z,?Z,ws,?wa,wa,Y,r,!r,!r,!r,!r") - (match_operand:DF 1 "input_operand" "d,m,d,Z,Z,ws,wa,ws,wa,j,r,Y,r,G,H,F"))] +(define_insn "*mov<mode>_hardfloat32" + [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=m,d,d,ws,?wa,Z,?Z,ws,?wa,wa,Y,r,!r,!r,!r,!r") + (match_operand:FMOVE64 1 "input_operand" "d,m,d,Z,Z,ws,wa,ws,wa,j,r,Y,r,G,H,F"))] "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT - && (gpc_reg_operand (operands[0], DFmode) - || gpc_reg_operand (operands[1], DFmode))" + && (gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode))" "@ stfd%U0%X0 %1,%0 lfd%U1%X1 %0,%1 @@ -8080,93 +8366,73 @@ # # #" - [(set_attr "type" "fpstore,fpload,fp,fpload,fpload,fpstore,fpstore,vecsimple,vecsimple,vecsimple,store,load,two,fp,fp,*") + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_u") + (const_string "fpstore"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "fpload_u") + (const_string "fpload"))) + (const_string "fp") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (const_string "fpload")) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (const_string "fpload")) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (const_string "fpstore")) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (const_string "fpstore")) + (const_string "vecsimple") + (const_string "vecsimple") + (const_string "vecsimple") + (const_string "store") + (const_string "load") + (const_string "two") + (const_string "fp") + (const_string "fp") + (const_string "*")]) (set_attr "length" "4,4,4,4,4,4,4,4,4,4,8,8,8,8,12,16")]) -(define_insn "*movdf_softfloat32" - [(set (match_operand:DF 0 "nonimmediate_operand" "=Y,r,r,r,r,r") - (match_operand:DF 1 "input_operand" "r,Y,r,G,H,F"))] +(define_insn "*mov<mode>_softfloat32" + [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=Y,r,r,r,r,r") + (match_operand:FMOVE64 1 "input_operand" "r,Y,r,G,H,F"))] "! TARGET_POWERPC64 && ((TARGET_FPRS && TARGET_SINGLE_FLOAT) || TARGET_SOFT_FLOAT || TARGET_E500_SINGLE) - && (gpc_reg_operand (operands[0], DFmode) - || gpc_reg_operand (operands[1], DFmode))" + && (gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode))" "#" [(set_attr "type" "store,load,two,*,*,*") (set_attr "length" "8,8,8,8,12,16")]) -;; Reload patterns to support gpr load/store with misaligned mem. -;; and multiple gpr load/store at offset >= 0xfffc -(define_expand "reload_<mode>_store" - [(parallel [(match_operand 0 "memory_operand" "=m") - (match_operand 1 "gpc_reg_operand" "r") - (match_operand:GPR 2 "register_operand" "=&b")])] - "" -{ - rs6000_secondary_reload_gpr (operands[1], operands[0], operands[2], true); - DONE; -}) - -(define_expand "reload_<mode>_load" - [(parallel [(match_operand 0 "gpc_reg_operand" "=r") - (match_operand 1 "memory_operand" "m") - (match_operand:GPR 2 "register_operand" "=b")])] - "" -{ - rs6000_secondary_reload_gpr (operands[0], operands[1], operands[2], false); - DONE; -}) - ; ld/std require word-aligned displacements -> 'Y' constraint. ; List Y->r and r->Y before r->r for reload. -(define_insn "*movdf_hardfloat64_mfpgpr" - [(set (match_operand:DF 0 "nonimmediate_operand" "=Y,r,!r,ws,?wa,ws,?wa,Z,?Z,m,d,d,wa,*c*l,!r,*h,!r,!r,!r,r,d") - (match_operand:DF 1 "input_operand" "r,Y,r,ws,?wa,Z,Z,ws,wa,d,m,d,j,r,h,0,G,H,F,d,r"))] - "TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS - && TARGET_DOUBLE_FLOAT - && (gpc_reg_operand (operands[0], DFmode) - || gpc_reg_operand (operands[1], DFmode))" +(define_insn "*mov<mode>_hardfloat64" + [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=m,d,d,ws,?wa,Z,?Z,ws,?wa,wa,Y,r,!r,*c*l,!r,*h,!r,!r,!r,r,wg") + (match_operand:FMOVE64 1 "input_operand" "d,m,d,Z,Z,ws,wa,ws,wa,j,r,Y,r,r,h,0,G,H,F,wg,r"))] + "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT + && (gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode))" "@ - std%U0%X0 %1,%0 - ld%U1%X1 %0,%1 - mr %0,%1 - xxlor %x0,%x1,%x1 - xxlor %x0,%x1,%x1 - lxsd%U1x %x0,%y1 - lxsd%U1x %x0,%y1 - stxsd%U0x %x1,%y0 - stxsd%U0x %x1,%y0 stfd%U0%X0 %1,%0 lfd%U1%X1 %0,%1 fmr %0,%1 - xxlxor %x0,%x0,%x0 - mt%0 %1 - mf%1 %0 - nop - # - # - # - mftgpr %0,%1 - mffgpr %0,%1" - [(set_attr "type" "store,load,*,fp,fp,fpload,fpload,fpstore,fpstore,fpstore,fpload,fp,vecsimple,mtjmpr,mfjmpr,*,*,*,*,mftgpr,mffgpr") - (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,8,12,16,4,4")]) - -; ld/std require word-aligned displacements -> 'Y' constraint. -; List Y->r and r->Y before r->r for reload. -(define_insn "*movdf_hardfloat64" - [(set (match_operand:DF 0 "nonimmediate_operand" "=m,d,d,Y,r,!r,ws,?wa,Z,?Z,ws,?wa,wa,*c*l,!r,*h,!r,!r,!r") - (match_operand:DF 1 "input_operand" "d,m,d,r,Y,r,Z,Z,ws,wa,ws,wa,j,r,h,0,G,H,F"))] - "TARGET_POWERPC64 && !TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS - && TARGET_DOUBLE_FLOAT - && (gpc_reg_operand (operands[0], DFmode) - || gpc_reg_operand (operands[1], DFmode))" - "@ - stfd%U0%X0 %1,%0 - lfd%U1%X1 %0,%1 - fmr %0,%1 - std%U0%X0 %1,%0 - ld%U1%X1 %0,%1 - mr %0,%1 lxsd%U1x %x0,%y1 lxsd%U1x %x0,%y1 stxsd%U0x %x1,%y0 @@ -8174,21 +8440,83 @@ xxlor %x0,%x1,%x1 xxlor %x0,%x1,%x1 xxlxor %x0,%x0,%x0 + std%U0%X0 %1,%0 + ld%U1%X1 %0,%1 + mr %0,%1 mt%0 %1 mf%1 %0 nop # # - #" - [(set_attr "type" "fpstore,fpload,fp,store,load,*,fpload,fpload,fpstore,fpstore,vecsimple,vecsimple,vecsimple,mtjmpr,mfjmpr,*,*,*,*") - (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,8,12,16")]) + # + mftgpr %0,%1 + mffgpr %0,%1" + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_u") + (const_string "fpstore"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "fpload_u") + (const_string "fpload"))) + (const_string "fp") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (const_string "fpload")) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (const_string "fpload")) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (const_string "fpstore")) + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (const_string "fpstore")) + (const_string "vecsimple") + (const_string "vecsimple") + (const_string "vecsimple") + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (const_string "*") + (const_string "mtjmpr") + (const_string "mfjmpr") + (const_string "*") + (const_string "*") + (const_string "*") + (const_string "*") + (const_string "mftgpr") + (const_string "mffgpr")]) + (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,8,12,16,4,4")]) -(define_insn "*movdf_softfloat64" - [(set (match_operand:DF 0 "nonimmediate_operand" "=Y,r,r,cl,r,r,r,r,*h") - (match_operand:DF 1 "input_operand" "r,Y,r,r,h,G,H,F,0"))] +(define_insn "*mov<mode>_softfloat64" + [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=Y,r,r,cl,r,r,r,r,*h") + (match_operand:FMOVE64 1 "input_operand" "r,Y,r,r,h,G,H,F,0"))] "TARGET_POWERPC64 && (TARGET_SOFT_FLOAT || !TARGET_FPRS) - && (gpc_reg_operand (operands[0], DFmode) - || gpc_reg_operand (operands[1], DFmode))" + && (gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode))" "@ std%U0%X0 %1,%0 ld%U1%X1 %0,%1 @@ -8199,38 +8527,57 @@ # # nop" - [(set_attr "type" "store,load,*,mtjmpr,mfjmpr,*,*,*,*") + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (const_string "*") + (const_string "mtjmpr") + (const_string "mfjmpr") + (const_string "*") + (const_string "*") + (const_string "*") + (const_string "*")]) (set_attr "length" "4,4,4,4,4,8,12,16,4")]) -(define_expand "movtf" - [(set (match_operand:TF 0 "general_operand" "") - (match_operand:TF 1 "any_operand" ""))] - "!TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128" - "{ rs6000_emit_move (operands[0], operands[1], TFmode); DONE; }") +(define_expand "mov<mode>" + [(set (match_operand:FMOVE128 0 "general_operand" "") + (match_operand:FMOVE128 1 "any_operand" ""))] + "" + "{ rs6000_emit_move (operands[0], operands[1], <MODE>mode); DONE; }") ;; It's important to list Y->r and r->Y before r->r because otherwise ;; reload, given m->r, will try to pick r->r and reload it, which ;; doesn't make progress. -(define_insn_and_split "*movtf_internal" - [(set (match_operand:TF 0 "nonimmediate_operand" "=m,d,d,Y,r,r") - (match_operand:TF 1 "input_operand" "d,m,d,r,YGHF,r"))] - "!TARGET_IEEEQUAD - && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128 - && (gpc_reg_operand (operands[0], TFmode) - || gpc_reg_operand (operands[1], TFmode))" +(define_insn_and_split "*mov<mode>_internal" + [(set (match_operand:FMOVE128 0 "nonimmediate_operand" "=m,d,d,Y,r,r") + (match_operand:FMOVE128 1 "input_operand" "d,m,d,r,YGHF,r"))] + "TARGET_HARD_FLOAT && TARGET_FPRS + && (gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode))" "#" "&& reload_completed" [(pc)] { rs6000_split_multireg_move (operands[0], operands[1]); DONE; } [(set_attr "length" "8,8,8,20,20,16")]) -(define_insn_and_split "*movtf_softfloat" - [(set (match_operand:TF 0 "rs6000_nonimmediate_operand" "=Y,r,r") - (match_operand:TF 1 "input_operand" "r,YGHF,r"))] - "!TARGET_IEEEQUAD - && (TARGET_SOFT_FLOAT || !TARGET_FPRS) && TARGET_LONG_DOUBLE_128 - && (gpc_reg_operand (operands[0], TFmode) - || gpc_reg_operand (operands[1], TFmode))" +(define_insn_and_split "*mov<mode>_softfloat" + [(set (match_operand:FMOVE128 0 "rs6000_nonimmediate_operand" "=Y,r,r") + (match_operand:FMOVE128 1 "input_operand" "r,YGHF,r"))] + "(TARGET_SOFT_FLOAT || !TARGET_FPRS) + && (gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode))" "#" "&& reload_completed" [(pc)] @@ -8515,6 +8862,33 @@ operands[6] = simplify_gen_subreg (DFmode, operands[0], TFmode, lo_word); }") +;; Reload helper functions used by rs6000_secondary_reload. The patterns all +;; must have 3 arguments, and scratch register constraint must be a single +;; constraint. + +;; Reload patterns to support gpr load/store with misaligned mem. +;; and multiple gpr load/store at offset >= 0xfffc +(define_expand "reload_<mode>_store" + [(parallel [(match_operand 0 "memory_operand" "=m") + (match_operand 1 "gpc_reg_operand" "r") + (match_operand:GPR 2 "register_operand" "=&b")])] + "" +{ + rs6000_secondary_reload_gpr (operands[1], operands[0], operands[2], true); + DONE; +}) + +(define_expand "reload_<mode>_load" + [(parallel [(match_operand 0 "gpc_reg_operand" "=r") + (match_operand 1 "memory_operand" "m") + (match_operand:GPR 2 "register_operand" "=b")])] + "" +{ + rs6000_secondary_reload_gpr (operands[0], operands[1], operands[2], false); + DONE; +}) + + ;; Next come the multi-word integer load and store and the load and store ;; multiple insns. @@ -8537,7 +8911,27 @@ fmr %0,%1 # xxlxor %x0,%x0,%x0" - [(set_attr "type" "store,load,*,fpstore,fpload,fp,*,vecsimple")]) + [(set_attr_alternative "type" + [(const_string "store") + (const_string "load") + (const_string "*") + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_u") + (const_string "fpstore"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "fpload_u") + (const_string "fpload"))) + (const_string "fp") + (const_string "*") + (const_string "vecsimple")])]) (define_split [(set (match_operand:DI 0 "gpc_reg_operand" "") @@ -8569,10 +8963,10 @@ [(pc)] { rs6000_split_multireg_move (operands[0], operands[1]); DONE; }) -(define_insn "*movdi_mfpgpr" - [(set (match_operand:DI 0 "nonimmediate_operand" "=Y,r,r,r,r,r,?m,?*d,?*d,r,*h,*h,r,?*d") - (match_operand:DI 1 "input_operand" "r,Y,r,I,L,nF,d,m,d,*h,r,0,*d,r"))] - "TARGET_POWERPC64 && TARGET_MFPGPR && TARGET_HARD_FLOAT && TARGET_FPRS +(define_insn "*movdi_internal64" + [(set (match_operand:DI 0 "nonimmediate_operand" "=Y,r,r,r,r,r,?m,?*d,?*d,?Z,?wa,?wa,r,*h,*h,?wa,r,?*wg") + (match_operand:DI 1 "input_operand" "r,Y,r,I,L,nF,d,m,d,wa,Z,wa,*h,r,0,O,*wg,r"))] + "TARGET_POWERPC64 && (gpc_reg_operand (operands[0], DImode) || gpc_reg_operand (operands[1], DImode))" "@ @@ -8585,36 +8979,65 @@ stfd%U0%X0 %1,%0 lfd%U1%X1 %0,%1 fmr %0,%1 + stxsd%U0x %x1,%y0 + lxsd%U1x %x0,%y1 + xxlor %x0,%x1,%x1 mf%1 %0 mt%0 %1 nop + xxlxor %x0,%x0,%x0 mftgpr %0,%1 mffgpr %0,%1" - [(set_attr "type" "store,load,*,*,*,*,fpstore,fpload,fp,mfjmpr,mtjmpr,*,mftgpr,mffgpr") - (set_attr "length" "4,4,4,4,4,20,4,4,4,4,4,4,4,4")]) - -(define_insn "*movdi_internal64" - [(set (match_operand:DI 0 "nonimmediate_operand" "=Y,r,r,r,r,r,?m,?*d,?*d,r,*h,*h,?wa") - (match_operand:DI 1 "input_operand" "r,Y,r,I,L,nF,d,m,d,*h,r,0,O"))] - "TARGET_POWERPC64 && (!TARGET_MFPGPR || !TARGET_HARD_FLOAT || !TARGET_FPRS) - && (gpc_reg_operand (operands[0], DImode) - || gpc_reg_operand (operands[1], DImode))" - "@ - std%U0%X0 %1,%0 - ld%U1%X1 %0,%1 - mr %0,%1 - li %0,%1 - lis %0,%v1 - # - stfd%U0%X0 %1,%0 - lfd%U1%X1 %0,%1 - fmr %0,%1 - mf%1 %0 - mt%0 %1 - nop - xxlxor %x0,%x0,%x0" - [(set_attr "type" "store,load,*,*,*,*,fpstore,fpload,fp,mfjmpr,mtjmpr,*,vecsimple") - (set_attr "length" "4,4,4,4,4,20,4,4,4,4,4,4,4")]) + [(set_attr_alternative "type" + [(if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "load_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "load_u") + (const_string "load"))) + (const_string "*") + (const_string "*") + (const_string "*") + (const_string "*") + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_u") + (const_string "fpstore"))) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (if_then_else + (match_test "update_address_mem (operands[1], VOIDmode)") + (const_string "fpload_u") + (const_string "fpload"))) + (const_string "fp") + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "fpstore_ux") + (const_string "fpstore")) + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (const_string "fpload")) + (const_string "vecsimple") + (const_string "mfjmpr") + (const_string "mtjmpr") + (const_string "*") + (const_string "vecsimple") + (const_string "mftgpr") + (const_string "mffgpr")]) + (set_attr "length" "4,4,4,4,4,20,4,4,4,4,4,4,4,4,4,4,4,4")]) ;; immediate value valid for a single instruction hiding in a const_double (define_insn "" @@ -8677,14 +9100,16 @@ FAIL; }") -;; TImode is similar, except that we usually want to compute the address into -;; a register and use lsi/stsi (the exception is during reload). +;; TImode/PTImode is similar, except that we usually want to compute the +;; address into a register and use lsi/stsi (the exception is during reload). -(define_insn "*movti_string" - [(set (match_operand:TI 0 "reg_or_mem_operand" "=Q,Y,????r,????r,????r,r") - (match_operand:TI 1 "input_operand" "r,r,Q,Y,r,n"))] +(define_insn "*mov<mode>_string" + [(set (match_operand:TI2 0 "reg_or_mem_operand" "=Q,Y,????r,????r,????r,r") + (match_operand:TI2 1 "input_operand" "r,r,Q,Y,r,n"))] "! TARGET_POWERPC64 - && (gpc_reg_operand (operands[0], TImode) || gpc_reg_operand (operands[1], TImode))" + && (<MODE>mode != TImode || VECTOR_MEM_NONE_P (TImode)) + && (gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode))" "* { switch (which_alternative) @@ -8714,27 +9139,28 @@ (const_string "always") (const_string "conditional")))]) -(define_insn "*movti_ppc64" - [(set (match_operand:TI 0 "nonimmediate_operand" "=Y,r,r") - (match_operand:TI 1 "input_operand" "r,Y,r"))] - "(TARGET_POWERPC64 && (gpc_reg_operand (operands[0], TImode) - || gpc_reg_operand (operands[1], TImode))) - && VECTOR_MEM_NONE_P (TImode)" +(define_insn "*mov<mode>_ppc64" + [(set (match_operand:TI2 0 "nonimmediate_operand" "=Y,r,r") + (match_operand:TI2 1 "input_operand" "r,Y,r"))] + "(TARGET_POWERPC64 + && (<MODE>mode != TImode || VECTOR_MEM_NONE_P (TImode)) + && (gpc_reg_operand (operands[0], <MODE>mode) + || gpc_reg_operand (operands[1], <MODE>mode)))" "#" [(set_attr "type" "store,load,*")]) (define_split - [(set (match_operand:TI 0 "gpc_reg_operand" "") - (match_operand:TI 1 "const_double_operand" ""))] - "TARGET_POWERPC64 && VECTOR_MEM_NONE_P (TImode)" + [(set (match_operand:TI2 0 "gpc_reg_operand" "") + (match_operand:TI2 1 "const_double_operand" ""))] + "TARGET_POWERPC64" [(set (match_dup 2) (match_dup 4)) (set (match_dup 3) (match_dup 5))] " { operands[2] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN == 0, - TImode); + <MODE>mode); operands[3] = operand_subword_force (operands[0], WORDS_BIG_ENDIAN != 0, - TImode); + <MODE>mode); if (GET_CODE (operands[1]) == CONST_DOUBLE) { operands[4] = GEN_INT (CONST_DOUBLE_HIGH (operands[1])); @@ -8750,9 +9176,9 @@ }") (define_split - [(set (match_operand:TI 0 "nonimmediate_operand" "") - (match_operand:TI 1 "input_operand" ""))] - "reload_completed && VECTOR_MEM_NONE_P (TImode) + [(set (match_operand:TI2 0 "nonimmediate_operand" "") + (match_operand:TI2 1 "input_operand" ""))] + "reload_completed && gpr_or_gpr_p (operands[0], operands[1])" [(pc)] { rs6000_split_multireg_move (operands[0], operands[1]); DONE; }) @@ -11252,7 +11678,14 @@ operands[1] = gen_rtx_REG (Pmode, 0); return "st<wd>%U0%X0 %1,%0"; } - [(set_attr "type" "store") + [(set (attr "type") + (if_then_else + (match_test "update_indexed_address_mem (operands[0], VOIDmode)") + (const_string "store_ux") + (if_then_else + (match_test "update_address_mem (operands[0], VOIDmode)") + (const_string "store_u") + (const_string "store")))) (set_attr "length" "4")]) (define_insn "probe_stack_range<P:mode>" diff --git a/gcc/config/rs6000/rs6000.opt b/gcc/config/rs6000/rs6000.opt index 8e3cea12185..17b77629fa1 100644 --- a/gcc/config/rs6000/rs6000.opt +++ b/gcc/config/rs6000/rs6000.opt @@ -514,3 +514,7 @@ Use/do not use r11 to hold the static link in calls to functions via pointers. msave-toc-indirect Target Report Var(TARGET_SAVE_TOC_INDIRECT) Save Control whether we save the TOC in the prologue for indirect calls or generate the save inline + +mvsx-timode +Target Undocumented Mask(VSX_TIMODE) Var(rs6000_isa_flags) +; Allow/disallow TImode in VSX registers diff --git a/gcc/config/rs6000/vector.md b/gcc/config/rs6000/vector.md index 5a6e1fb3026..c1d00ca2a9b 100644 --- a/gcc/config/rs6000/vector.md +++ b/gcc/config/rs6000/vector.md @@ -54,7 +54,7 @@ (define_mode_iterator VEC_64 [V2DI V2DF]) ;; Vector reload iterator -(define_mode_iterator VEC_R [V16QI V8HI V4SI V2DI V4SF V2DF DF TI]) +(define_mode_iterator VEC_R [V16QI V8HI V4SI V2DI V4SF V2DF SF SD SI DF DD DI TI]) ;; Base type from vector mode (define_mode_attr VEC_base [(V16QI "QI") @@ -249,7 +249,7 @@ [(set (match_operand:VEC_F 0 "vfloat_operand" "") (mult:VEC_F (match_operand:VEC_F 1 "vfloat_operand" "") (match_operand:VEC_F 2 "vfloat_operand" "")))] - "VECTOR_UNIT_VSX_P (<MODE>mode) || VECTOR_UNIT_ALTIVEC_P (<MODE>mode)" + "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)" { if (<MODE>mode == V4SFmode && VECTOR_UNIT_ALTIVEC_P (<MODE>mode)) { @@ -395,7 +395,7 @@ (match_operand:VEC_I 5 "vint_operand" "")]) (match_operand:VEC_I 1 "vint_operand" "") (match_operand:VEC_I 2 "vint_operand" "")))] - "VECTOR_UNIT_ALTIVEC_P (<MODE>mode)" + "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)" " { if (rs6000_emit_vector_cond_expr (operands[0], operands[1], operands[2], @@ -451,7 +451,7 @@ (match_operand:VEC_I 5 "vint_operand" "")]) (match_operand:VEC_I 1 "vint_operand" "") (match_operand:VEC_I 2 "vint_operand" "")))] - "VECTOR_UNIT_ALTIVEC_P (<MODE>mode)" + "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)" " { if (rs6000_emit_vector_cond_expr (operands[0], operands[1], operands[2], @@ -505,14 +505,14 @@ [(set (match_operand:VEC_I 0 "vint_operand" "") (gtu:VEC_I (match_operand:VEC_I 1 "vint_operand" "") (match_operand:VEC_I 2 "vint_operand" "")))] - "VECTOR_UNIT_ALTIVEC_P (<MODE>mode)" + "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)" "") (define_expand "vector_geu<mode>" [(set (match_operand:VEC_I 0 "vint_operand" "") (geu:VEC_I (match_operand:VEC_I 1 "vint_operand" "") (match_operand:VEC_I 2 "vint_operand" "")))] - "VECTOR_UNIT_ALTIVEC_P (<MODE>mode)" + "VECTOR_UNIT_ALTIVEC_OR_VSX_P (<MODE>mode)" "") (define_insn_and_split "*vector_uneq<mode>" @@ -709,45 +709,55 @@ ;; Vector logical instructions +;; Do not support TImode logical instructions on 32-bit at present, because the +;; compiler will see that we have a TImode and when it wanted DImode, and +;; convert the DImode to TImode, store it on the stack, and load it in a VSX +;; register. (define_expand "xor<mode>3" [(set (match_operand:VEC_L 0 "vlogical_operand" "") (xor:VEC_L (match_operand:VEC_L 1 "vlogical_operand" "") (match_operand:VEC_L 2 "vlogical_operand" "")))] - "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)" + "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "") (define_expand "ior<mode>3" [(set (match_operand:VEC_L 0 "vlogical_operand" "") (ior:VEC_L (match_operand:VEC_L 1 "vlogical_operand" "") (match_operand:VEC_L 2 "vlogical_operand" "")))] - "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)" + "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "") (define_expand "and<mode>3" [(set (match_operand:VEC_L 0 "vlogical_operand" "") (and:VEC_L (match_operand:VEC_L 1 "vlogical_operand" "") (match_operand:VEC_L 2 "vlogical_operand" "")))] - "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)" + "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "") (define_expand "one_cmpl<mode>2" [(set (match_operand:VEC_L 0 "vlogical_operand" "") (not:VEC_L (match_operand:VEC_L 1 "vlogical_operand" "")))] - "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)" + "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "") (define_expand "nor<mode>3" [(set (match_operand:VEC_L 0 "vlogical_operand" "") (not:VEC_L (ior:VEC_L (match_operand:VEC_L 1 "vlogical_operand" "") (match_operand:VEC_L 2 "vlogical_operand" ""))))] - "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)" + "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "") (define_expand "andc<mode>3" [(set (match_operand:VEC_L 0 "vlogical_operand" "") (and:VEC_L (not:VEC_L (match_operand:VEC_L 2 "vlogical_operand" "")) (match_operand:VEC_L 1 "vlogical_operand" "")))] - "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode)" + "VECTOR_MEM_ALTIVEC_OR_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "") ;; Same size conversions diff --git a/gcc/config/rs6000/vsx.md b/gcc/config/rs6000/vsx.md index dcb1f64d4ee..042bb5c73d6 100644 --- a/gcc/config/rs6000/vsx.md +++ b/gcc/config/rs6000/vsx.md @@ -48,7 +48,7 @@ (V2DF "vd2") (V2DI "vd2") (DF "d") - (TI "vw4")]) + (TI "vd2")]) ;; Map into the appropriate suffix based on the type (define_mode_attr VSs [(V16QI "sp") @@ -59,7 +59,7 @@ (V2DI "dp") (DF "dp") (SF "sp") - (TI "sp")]) + (TI "dp")]) ;; Map the register class used (define_mode_attr VSr [(V16QI "v") @@ -70,7 +70,7 @@ (V2DF "wd") (DF "ws") (SF "d") - (TI "wd")]) + (TI "wt")]) ;; Map the register class used for float<->int conversions (define_mode_attr VSr2 [(V2DF "wd") @@ -115,7 +115,6 @@ (V4SF "v") (V2DI "v") (V2DF "v") - (TI "v") (DF "s")]) ;; Appropriate type for add ops (and other simple FP ops) @@ -268,12 +267,13 @@ } [(set_attr "type" "vecstore,vecload,vecsimple,vecstore,vecload,vecsimple,*,*,*,vecsimple,vecsimple,*,vecstore,vecload")]) -;; Unlike other VSX moves, allow the GPRs, since a normal use of TImode is for -;; unions. However for plain data movement, slightly favor the vector loads -(define_insn "*vsx_movti" - [(set (match_operand:TI 0 "nonimmediate_operand" "=Z,wa,wa,?Y,?r,?r,wa,v,v,wZ") - (match_operand:TI 1 "input_operand" "wa,Z,wa,r,Y,r,j,W,wZ,v"))] - "VECTOR_MEM_VSX_P (TImode) +;; Unlike other VSX moves, allow the GPRs even for reloading, since a normal +;; use of TImode is for unions. However for plain data movement, slightly +;; favor the vector loads +(define_insn "*vsx_movti_64bit" + [(set (match_operand:TI 0 "nonimmediate_operand" "=Z,wa,wa,wa,v, v,wZ,?Y,?r,?r") + (match_operand:TI 1 "input_operand" "wa, Z,wa, j,W,wZ, v, r, Y, r"))] + "TARGET_POWERPC64 && VECTOR_MEM_VSX_P (TImode) && (register_operand (operands[0], TImode) || register_operand (operands[1], TImode))" { @@ -289,27 +289,87 @@ return "xxlor %x0,%x1,%x1"; case 3: + return "xxlxor %x0,%x0,%x0"; + case 4: + return output_vec_const_move (operands); + case 5: - return "#"; + return "stvx %1,%y0"; case 6: - return "xxlxor %x0,%x0,%x0"; + return "lvx %0,%y1"; case 7: + case 8: + case 9: + return "#"; + + default: + gcc_unreachable (); + } +} + [(set_attr "type" "vecstore,vecload,vecsimple,vecsimple,vecsimple,vecstore,vecload,*,*,*") + (set_attr "length" " 4, 4, 4, 4, 8, 4, 4,8,8,8")]) + +(define_insn "*vsx_movti_32bit" + [(set (match_operand:TI 0 "nonimmediate_operand" "=Z,wa,wa,wa,v, v,wZ,Q,Y,????r,????r,????r,r") + (match_operand:TI 1 "input_operand" "wa, Z,wa, j,W,wZ, v,r,r, Q, Y, r,n"))] + "! TARGET_POWERPC64 && VECTOR_MEM_VSX_P (TImode) + && (register_operand (operands[0], TImode) + || register_operand (operands[1], TImode))" +{ + switch (which_alternative) + { + case 0: + return "stxvd2x %x1,%y0"; + + case 1: + return "lxvd2x %x0,%y1"; + + case 2: + return "xxlor %x0,%x1,%x1"; + + case 3: + return "xxlxor %x0,%x0,%x0"; + + case 4: return output_vec_const_move (operands); - case 8: + case 5: return "stvx %1,%y0"; - case 9: + case 6: return "lvx %0,%y1"; + case 7: + if (TARGET_STRING) + return \"stswi %1,%P0,16\"; + + case 8: + return \"#\"; + + case 9: + /* If the address is not used in the output, we can use lsi. Otherwise, + fall through to generating four loads. */ + if (TARGET_STRING + && ! reg_overlap_mentioned_p (operands[0], operands[1])) + return \"lswi %0,%P1,16\"; + /* ... fall through ... */ + + case 10: + case 11: + case 12: + return \"#\"; default: gcc_unreachable (); } } - [(set_attr "type" "vecstore,vecload,vecsimple,*,*,*,vecsimple,*,vecstore,vecload")]) + [(set_attr "type" "vecstore,vecload,vecsimple,vecsimple,vecsimple,vecstore,vecload,store_ux,store_ux,load_ux,load_ux, *, *") + (set_attr "length" " 4, 4, 4, 4, 8, 4, 4, 16, 16, 16, 16,16,16") + (set (attr "cell_micro") (if_then_else (match_test "TARGET_STRING") + (const_string "always") + (const_string "conditional")))]) ;; Explicit load/store expanders for the builtin functions (define_expand "vsx_load_<mode>" @@ -319,8 +379,8 @@ "") (define_expand "vsx_store_<mode>" - [(set (match_operand:VEC_M 0 "memory_operand" "") - (match_operand:VEC_M 1 "vsx_register_operand" ""))] + [(set (match_operand:VSX_M 0 "memory_operand" "") + (match_operand:VSX_M 1 "vsx_register_operand" ""))] "VECTOR_MEM_VSX_P (<MODE>mode)" "") @@ -1026,38 +1086,46 @@ (set_attr "fp_type" "<VSfptype_simple>")]) -;; Logical and permute operations +;; Logical operations +;; Do not support TImode logical instructions on 32-bit at present, because the +;; compiler will see that we have a TImode and when it wanted DImode, and +;; convert the DImode to TImode, store it on the stack, and load it in a VSX +;; register. (define_insn "*vsx_and<mode>3" [(set (match_operand:VSX_L 0 "vsx_register_operand" "=<VSr>,?wa") (and:VSX_L - (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,?wa") - (match_operand:VSX_L 2 "vsx_register_operand" "<VSr>,?wa")))] - "VECTOR_MEM_VSX_P (<MODE>mode)" + (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,wa") + (match_operand:VSX_L 2 "vsx_register_operand" "<VSr>,wa")))] + "VECTOR_MEM_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "xxland %x0,%x1,%x2" [(set_attr "type" "vecsimple")]) (define_insn "*vsx_ior<mode>3" [(set (match_operand:VSX_L 0 "vsx_register_operand" "=<VSr>,?wa") - (ior:VSX_L (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,?wa") - (match_operand:VSX_L 2 "vsx_register_operand" "<VSr>,?wa")))] - "VECTOR_MEM_VSX_P (<MODE>mode)" + (ior:VSX_L (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,wa") + (match_operand:VSX_L 2 "vsx_register_operand" "<VSr>,wa")))] + "VECTOR_MEM_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "xxlor %x0,%x1,%x2" [(set_attr "type" "vecsimple")]) (define_insn "*vsx_xor<mode>3" [(set (match_operand:VSX_L 0 "vsx_register_operand" "=<VSr>,?wa") (xor:VSX_L - (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,?wa") - (match_operand:VSX_L 2 "vsx_register_operand" "<VSr>,?wa")))] - "VECTOR_MEM_VSX_P (<MODE>mode)" + (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,wa") + (match_operand:VSX_L 2 "vsx_register_operand" "<VSr>,wa")))] + "VECTOR_MEM_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "xxlxor %x0,%x1,%x2" [(set_attr "type" "vecsimple")]) (define_insn "*vsx_one_cmpl<mode>2" [(set (match_operand:VSX_L 0 "vsx_register_operand" "=<VSr>,?wa") (not:VSX_L - (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,?wa")))] - "VECTOR_MEM_VSX_P (<MODE>mode)" + (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,wa")))] + "VECTOR_MEM_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "xxlnor %x0,%x1,%x1" [(set_attr "type" "vecsimple")]) @@ -1067,7 +1135,8 @@ (ior:VSX_L (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,?wa") (match_operand:VSX_L 2 "vsx_register_operand" "<VSr>,?wa"))))] - "VECTOR_MEM_VSX_P (<MODE>mode)" + "VECTOR_MEM_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "xxlnor %x0,%x1,%x2" [(set_attr "type" "vecsimple")]) @@ -1077,7 +1146,8 @@ (not:VSX_L (match_operand:VSX_L 2 "vsx_register_operand" "<VSr>,?wa")) (match_operand:VSX_L 1 "vsx_register_operand" "<VSr>,?wa")))] - "VECTOR_MEM_VSX_P (<MODE>mode)" + "VECTOR_MEM_VSX_P (<MODE>mode) + && (<MODE>mode != TImode || TARGET_POWERPC64)" "xxlandc %x0,%x1,%x2" [(set_attr "type" "vecsimple")]) @@ -1086,11 +1156,10 @@ ;; Build a V2DF/V2DI vector from two scalars (define_insn "vsx_concat_<mode>" - [(set (match_operand:VSX_D 0 "vsx_register_operand" "=wd,?wa") - (unspec:VSX_D - [(match_operand:<VS_scalar> 1 "vsx_register_operand" "ws,wa") - (match_operand:<VS_scalar> 2 "vsx_register_operand" "ws,wa")] - UNSPEC_VSX_CONCAT))] + [(set (match_operand:VSX_D 0 "vsx_register_operand" "=<VSr>,?wa") + (vec_concat:VSX_D + (match_operand:<VS_scalar> 1 "vsx_register_operand" "ws,wa") + (match_operand:<VS_scalar> 2 "vsx_register_operand" "ws,wa")))] "VECTOR_MEM_VSX_P (<MODE>mode)" "xxpermdi %x0,%x1,%x2,0" [(set_attr "type" "vecperm")]) @@ -1148,7 +1217,11 @@ (parallel [(const_int 0)])))] "VECTOR_MEM_VSX_P (<MODE>mode) && WORDS_BIG_ENDIAN" "lxsd%U1x %x0,%y1" - [(set_attr "type" "fpload") + [(set (attr "type") + (if_then_else + (match_test "update_indexed_address_mem (operands[1], VOIDmode)") + (const_string "fpload_ux") + (const_string "fpload"))) (set_attr "length" "4")]) ;; Extract a SF element from V4SF @@ -1212,8 +1285,8 @@ if (<MODE>mode != V2DImode) { target = gen_lowpart (V2DImode, target); - op0 = gen_lowpart (V2DImode, target); - op1 = gen_lowpart (V2DImode, target); + op0 = gen_lowpart (V2DImode, op0); + op1 = gen_lowpart (V2DImode, op1); } } emit_insn (gen (target, op0, op1, perm0, perm1)); diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c index 7e87dcd547d..f6aa581e4b8 100644 --- a/gcc/config/s390/s390.c +++ b/gcc/config/s390/s390.c @@ -5738,7 +5738,7 @@ addr_generation_dependency_p (rtx dep_rtx, rtx insn) { rtx target, pat; - if (GET_CODE (dep_rtx) == INSN) + if (NONJUMP_INSN_P (dep_rtx)) dep_rtx = PATTERN (dep_rtx); if (GET_CODE (dep_rtx) == SET) @@ -5978,7 +5978,7 @@ s390_split_branches (void) for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) { - if (GET_CODE (insn) != JUMP_INSN) + if (! JUMP_P (insn)) continue; pat = PATTERN (insn); @@ -6398,7 +6398,7 @@ s390_find_constant (struct constant_pool *pool, rtx val, static rtx s390_execute_label (rtx insn) { - if (GET_CODE (insn) == INSN + if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == PARALLEL && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == UNSPEC && XINT (XVECEXP (PATTERN (insn), 0, 0), 1) == UNSPEC_EXECUTE) @@ -6603,7 +6603,7 @@ s390_mainpool_start (void) for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) { - if (GET_CODE (insn) == INSN + if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SET && GET_CODE (SET_SRC (PATTERN (insn))) == UNSPEC_VOLATILE && XINT (SET_SRC (PATTERN (insn)), 1) == UNSPECV_MAIN_POOL) @@ -6616,7 +6616,7 @@ s390_mainpool_start (void) { s390_add_execute (pool, insn); } - else if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN) + else if (NONJUMP_INSN_P (insn) || CALL_P (insn)) { rtx pool_ref = NULL_RTX; find_constant_pool_ref (PATTERN (insn), &pool_ref); @@ -6758,7 +6758,7 @@ s390_mainpool_finish (struct constant_pool *pool) if (INSN_P (insn)) replace_ltrel_base (&PATTERN (insn)); - if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN) + if (NONJUMP_INSN_P (insn) || CALL_P (insn)) { rtx addr, pool_ref = NULL_RTX; find_constant_pool_ref (PATTERN (insn), &pool_ref); @@ -6840,7 +6840,7 @@ s390_chunkify_start (void) s390_add_execute (curr_pool, insn); s390_add_pool_insn (curr_pool, insn); } - else if (GET_CODE (insn) == INSN || CALL_P (insn)) + else if (NONJUMP_INSN_P (insn) || CALL_P (insn)) { rtx pool_ref = NULL_RTX; find_constant_pool_ref (PATTERN (insn), &pool_ref); @@ -6867,7 +6867,7 @@ s390_chunkify_start (void) } } - if (GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == CODE_LABEL) + if (JUMP_P (insn) || LABEL_P (insn)) { if (curr_pool) s390_add_pool_insn (curr_pool, insn); @@ -6911,7 +6911,7 @@ s390_chunkify_start (void) Those will have an effect on code size, which we need to consider here. This calculation makes rather pessimistic worst-case assumptions. */ - if (GET_CODE (insn) == CODE_LABEL) + if (LABEL_P (insn)) extra_size += 6; if (chunk_size < S390_POOL_CHUNK_MIN @@ -6920,7 +6920,7 @@ s390_chunkify_start (void) continue; /* Pool chunks can only be inserted after BARRIERs ... */ - if (GET_CODE (insn) == BARRIER) + if (BARRIER_P (insn)) { s390_end_pool (curr_pool, insn); curr_pool = NULL; @@ -6937,7 +6937,7 @@ s390_chunkify_start (void) if (!section_switch_p) { /* We can insert the barrier only after a 'real' insn. */ - if (GET_CODE (insn) != INSN && GET_CODE (insn) != CALL_INSN) + if (! NONJUMP_INSN_P (insn) && ! CALL_P (insn)) continue; if (get_attr_length (insn) == 0) continue; @@ -7009,11 +7009,11 @@ s390_chunkify_start (void) Don't do that, however, if it is the label before a jump table. */ - if (GET_CODE (insn) == CODE_LABEL + if (LABEL_P (insn) && (LABEL_PRESERVE_P (insn) || LABEL_NAME (insn))) { rtx vec_insn = next_real_insn (insn); - rtx vec_pat = vec_insn && GET_CODE (vec_insn) == JUMP_INSN ? + rtx vec_pat = vec_insn && JUMP_P (vec_insn) ? PATTERN (vec_insn) : NULL_RTX; if (!vec_pat || !(GET_CODE (vec_pat) == ADDR_VEC @@ -7023,7 +7023,7 @@ s390_chunkify_start (void) /* If we have a direct jump (conditional or unconditional) or a casesi jump, check all potential targets. */ - else if (GET_CODE (insn) == JUMP_INSN) + else if (JUMP_P (insn)) { rtx pat = PATTERN (insn); if (GET_CODE (pat) == PARALLEL && XVECLEN (pat, 0) > 2) @@ -7048,7 +7048,7 @@ s390_chunkify_start (void) /* Find the jump table used by this casesi jump. */ rtx vec_label = XEXP (XEXP (XVECEXP (pat, 0, 1), 0), 0); rtx vec_insn = next_real_insn (vec_label); - rtx vec_pat = vec_insn && GET_CODE (vec_insn) == JUMP_INSN ? + rtx vec_pat = vec_insn && JUMP_P (vec_insn) ? PATTERN (vec_insn) : NULL_RTX; if (vec_pat && (GET_CODE (vec_pat) == ADDR_VEC @@ -7082,7 +7082,7 @@ s390_chunkify_start (void) /* Insert base register reload insns at every far label. */ for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == CODE_LABEL + if (LABEL_P (insn) && bitmap_bit_p (far_labels, CODE_LABEL_NUMBER (insn))) { struct constant_pool *pool = s390_find_pool (pool_list, insn); @@ -7128,7 +7128,7 @@ s390_chunkify_finish (struct constant_pool *pool_list) if (!curr_pool) continue; - if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN) + if (NONJUMP_INSN_P (insn) || CALL_P (insn)) { rtx addr, pool_ref = NULL_RTX; find_constant_pool_ref (PATTERN (insn), &pool_ref); @@ -7181,9 +7181,9 @@ s390_chunkify_cancel (struct constant_pool *pool_list) rtx jump = barrier? PREV_INSN (barrier) : NULL_RTX; rtx label = NEXT_INSN (curr_pool->pool_insn); - if (jump && GET_CODE (jump) == JUMP_INSN - && barrier && GET_CODE (barrier) == BARRIER - && label && GET_CODE (label) == CODE_LABEL + if (jump && JUMP_P (jump) + && barrier && BARRIER_P (barrier) + && label && LABEL_P (label) && GET_CODE (PATTERN (jump)) == SET && SET_DEST (PATTERN (jump)) == pc_rtx && GET_CODE (SET_SRC (PATTERN (jump))) == LABEL_REF @@ -7203,7 +7203,7 @@ s390_chunkify_cancel (struct constant_pool *pool_list) { rtx next_insn = NEXT_INSN (insn); - if (GET_CODE (insn) == INSN + if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SET && GET_CODE (SET_SRC (PATTERN (insn))) == UNSPEC && XINT (SET_SRC (PATTERN (insn)), 1) == UNSPEC_RELOAD_BASE) @@ -10080,7 +10080,7 @@ s390_optimize_prologue (void) next_insn = NEXT_INSN (insn); - if (GET_CODE (insn) != INSN) + if (! NONJUMP_INSN_P (insn)) continue; if (GET_CODE (PATTERN (insn)) == PARALLEL diff --git a/gcc/config/sh/linux.h b/gcc/config/sh/linux.h index 8bc7de83ab0..9e8f32d06d1 100644 --- a/gcc/config/sh/linux.h +++ b/gcc/config/sh/linux.h @@ -39,8 +39,7 @@ along with GCC; see the file COPYING3. If not see #undef TARGET_DEFAULT #define TARGET_DEFAULT \ - (TARGET_CPU_DEFAULT | MASK_USERMODE | TARGET_ENDIAN_DEFAULT \ - | TARGET_OPT_DEFAULT) + (TARGET_CPU_DEFAULT | TARGET_ENDIAN_DEFAULT | TARGET_OPT_DEFAULT) #define TARGET_ASM_FILE_END file_end_indicate_exec_stack @@ -146,5 +145,8 @@ along with GCC; see the file COPYING3. If not see else if (TARGET_SH1) \ sh_atomic_model_str = "soft-imask"; \ } \ + /* Set -musermode if it hasn't been specified. */ \ + if (global_options_set.x_TARGET_USERMODE == 0) \ + TARGET_USERMODE = true; \ } \ while (0) diff --git a/gcc/config/sh/netbsd-elf.h b/gcc/config/sh/netbsd-elf.h index a390f40feea..807638a0f79 100644 --- a/gcc/config/sh/netbsd-elf.h +++ b/gcc/config/sh/netbsd-elf.h @@ -58,7 +58,7 @@ along with GCC; see the file COPYING3. If not see #undef TARGET_DEFAULT #define TARGET_DEFAULT \ - (TARGET_CPU_DEFAULT | MASK_USERMODE | TARGET_ENDIAN_DEFAULT) + (TARGET_CPU_DEFAULT | TARGET_ENDIAN_DEFAULT) /* Define because we use the label and we do not need them. */ #define NO_PROFILE_COUNTERS 1 @@ -94,3 +94,13 @@ while (0) #define SH_DIV_STRATEGY_DEFAULT SH_DIV_CALL2 #undef SH_DIV_STR_FOR_SIZE #define SH_DIV_STR_FOR_SIZE "call2" + +#undef SUBTARGET_OVERRIDE_OPTIONS +#define SUBTARGET_OVERRIDE_OPTIONS \ + do \ + { \ + /* Set -musermode if it hasn't been specified. */ \ + if (global_options_set.x_TARGET_USERMODE == 0) \ + TARGET_USERMODE = true; \ + } \ + while (0) diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c index dcbd93286ed..44e1e4ce30e 100644 --- a/gcc/config/sh/sh.c +++ b/gcc/config/sh/sh.c @@ -816,8 +816,7 @@ sh_option_override (void) if (! strcmp (sh_div_str, "call-div1")) sh_div_strategy = SH_DIV_CALL_DIV1; else if (! strcmp (sh_div_str, "call-fp") - && (TARGET_FPU_DOUBLE - || (TARGET_HARD_SH4 && TARGET_SH2E) + && (TARGET_FPU_DOUBLE || TARGET_FPU_SINGLE_ONLY || (TARGET_SHCOMPACT && TARGET_FPU_ANY))) sh_div_strategy = SH_DIV_CALL_FP; else if (! strcmp (sh_div_str, "call-table") && TARGET_DYNSHIFT) diff --git a/gcc/config/sh/sh.h b/gcc/config/sh/sh.h index ecd6c17e553..3744f980fe7 100644 --- a/gcc/config/sh/sh.h +++ b/gcc/config/sh/sh.h @@ -138,14 +138,16 @@ extern int code_for_indirect_jump_scratch; | MASK_SH2 | MASK_SH1) #define SELECT_SH2A_NOFPU (MASK_HARD_SH2A | MASK_SH2 | MASK_SH1) #define SELECT_SH2A_SINGLE_ONLY (MASK_SH_E | MASK_HARD_SH2A | MASK_SH2 \ - | MASK_SH1 | MASK_FPU_SINGLE) + | MASK_SH1 | MASK_FPU_SINGLE \ + | MASK_FPU_SINGLE_ONLY) #define SELECT_SH2A_SINGLE (MASK_SH_E | MASK_HARD_SH2A \ | MASK_FPU_SINGLE | MASK_HARD_SH2A_DOUBLE \ | MASK_SH2 | MASK_SH1) #define SELECT_SH3 (MASK_SH3 | SELECT_SH2) #define SELECT_SH3E (MASK_SH_E | MASK_FPU_SINGLE | SELECT_SH3) #define SELECT_SH4_NOFPU (MASK_HARD_SH4 | SELECT_SH3) -#define SELECT_SH4_SINGLE_ONLY (MASK_HARD_SH4 | SELECT_SH3E) +#define SELECT_SH4_SINGLE_ONLY (MASK_HARD_SH4 | SELECT_SH3E \ + | MASK_FPU_SINGLE_ONLY) #define SELECT_SH4 (MASK_SH4 | MASK_SH_E | MASK_HARD_SH4 \ | SELECT_SH3) #define SELECT_SH4_SINGLE (MASK_FPU_SINGLE | SELECT_SH4) @@ -212,7 +214,8 @@ extern int code_for_indirect_jump_scratch; /* Reset all target-selection flags. */ #define MASK_ARCH (MASK_SH1 | MASK_SH2 | MASK_SH3 | MASK_SH_E | MASK_SH4 \ | MASK_HARD_SH2A | MASK_HARD_SH2A_DOUBLE | MASK_SH4A \ - | MASK_HARD_SH4 | MASK_FPU_SINGLE | MASK_SH5) + | MASK_HARD_SH4 | MASK_FPU_SINGLE | MASK_SH5 \ + | MASK_FPU_SINGLE_ONLY) /* This defaults us to big-endian. */ #ifndef TARGET_ENDIAN_DEFAULT diff --git a/gcc/config/sh/sh.md b/gcc/config/sh/sh.md index 75b102c3fa7..42ef5e142d8 100644 --- a/gcc/config/sh/sh.md +++ b/gcc/config/sh/sh.md @@ -2154,7 +2154,7 @@ (clobber (reg:SI PR_REG)) (clobber (reg:SI R4_REG)) (use (match_operand:SI 1 "arith_reg_operand" "r"))] - "TARGET_SH1 && (! TARGET_SH4 || TARGET_DIVIDE_CALL_DIV1)" + "TARGET_SH1 && TARGET_DIVIDE_CALL_DIV1" "jsr @%1%#" [(set_attr "type" "sfunc") (set_attr "needs_delay_slot" "yes")]) @@ -2217,7 +2217,7 @@ (clobber (reg:SI R5_REG)) (use (reg:PSI FPSCR_REG)) (use (match_operand:SI 1 "arith_reg_operand" "r"))] - "TARGET_SH4 && ! TARGET_FPU_SINGLE" + "TARGET_FPU_DOUBLE && ! TARGET_FPU_SINGLE" "jsr @%1%#" [(set_attr "type" "sfunc") (set_attr "fp_mode" "double") @@ -2236,7 +2236,8 @@ (clobber (reg:SI R4_REG)) (clobber (reg:SI R5_REG)) (use (match_operand:SI 1 "arith_reg_operand" "r"))] - "(TARGET_HARD_SH4 || TARGET_SHCOMPACT) && TARGET_FPU_SINGLE" + "(TARGET_FPU_SINGLE_ONLY || TARGET_FPU_DOUBLE || TARGET_SHCOMPACT) + && TARGET_FPU_SINGLE" "jsr @%1%#" [(set_attr "type" "sfunc") (set_attr "needs_delay_slot" "yes")]) @@ -2358,7 +2359,7 @@ (clobber (reg:SI R2_REG)) (clobber (reg:SI R3_REG)) (use (match_operand:SI 1 "arith_reg_operand" "r"))] - "TARGET_SH1 && (! TARGET_SH4 || TARGET_DIVIDE_CALL_DIV1)" + "TARGET_SH1 && TARGET_DIVIDE_CALL_DIV1" "jsr @%1%#" [(set_attr "type" "sfunc") (set_attr "needs_delay_slot" "yes")]) @@ -2487,7 +2488,7 @@ (clobber (reg:DF DR2_REG)) (use (reg:PSI FPSCR_REG)) (use (match_operand:SI 1 "arith_reg_operand" "r"))] - "TARGET_SH4 && ! TARGET_FPU_SINGLE" + "TARGET_FPU_DOUBLE && ! TARGET_FPU_SINGLE" "jsr @%1%#" [(set_attr "type" "sfunc") (set_attr "fp_mode" "double") @@ -2501,7 +2502,8 @@ (clobber (reg:DF DR2_REG)) (clobber (reg:SI R2_REG)) (use (match_operand:SI 1 "arith_reg_operand" "r"))] - "(TARGET_HARD_SH4 || TARGET_SHCOMPACT) && TARGET_FPU_SINGLE" + "(TARGET_FPU_SINGLE_ONLY || TARGET_FPU_DOUBLE || TARGET_SHCOMPACT) + && TARGET_FPU_SINGLE" "jsr @%1%#" [(set_attr "type" "sfunc") (set_attr "needs_delay_slot" "yes")]) diff --git a/gcc/config/sh/sh.opt b/gcc/config/sh/sh.opt index 0ee36be45fa..c314e144c21 100644 --- a/gcc/config/sh/sh.opt +++ b/gcc/config/sh/sh.opt @@ -24,6 +24,10 @@ Mask(SH_E) ;; Set if the default precision of th FPU is single. Mask(FPU_SINGLE) +;; Set if the a double-precision FPU is present but is restricted to +;; single precision usage only. +Mask(FPU_SINGLE_ONLY) + ;; Set if we should generate code using type 2A insns. Mask(HARD_SH2A) @@ -339,7 +343,7 @@ Target RejectNegative Joined UInteger Var(sh_multcost) Init(-1) Cost to assume for a multiply insn musermode -Target Report RejectNegative Mask(USERMODE) +Target Report RejectNegative Var(TARGET_USERMODE) Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate if the inline code would not work in user mode. ;; We might want to enable this by default for TARGET_HARD_SH4, because diff --git a/gcc/config/sol2.c b/gcc/config/sol2.c index 95c7e0f4165..7c7c429db3d 100644 --- a/gcc/config/sol2.c +++ b/gcc/config/sol2.c @@ -291,8 +291,8 @@ solaris_file_end (void) void solaris_override_options (void) { - /* Don't emit DWARF3/4 unless specifically selected. Solaris ld cannot - handle CIE version 3 in .eh_frame. */ - if (!global_options_set.x_dwarf_version) + /* Older versions of Solaris ld cannot handle CIE version 3 in .eh_frame. + Don't emit DWARF3/4 unless specifically selected if so. */ + if (!HAVE_LD_EH_FRAME_CIEV3 && !global_options_set.x_dwarf_version) dwarf_version = 2; } diff --git a/gcc/config/sparc/sparc.c b/gcc/config/sparc/sparc.c index 08c2894fbbc..3e98325bd3b 100644 --- a/gcc/config/sparc/sparc.c +++ b/gcc/config/sparc/sparc.c @@ -3063,10 +3063,10 @@ emit_cbcond_nop (rtx insn) if (!next) return 1; - if (GET_CODE (next) == INSN + if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE) next = XVECEXP (PATTERN (next), 0, 0); - else if (GET_CODE (next) == CALL_INSN + else if (CALL_P (next) && GET_CODE (PATTERN (next)) == PARALLEL) { rtx delay = XVECEXP (PATTERN (next), 0, 1); @@ -3222,7 +3222,7 @@ eligible_for_return_delay (rtx trial) int regno; rtx pat; - if (GET_CODE (trial) != INSN) + if (! NONJUMP_INSN_P (trial)) return 0; if (get_attr_length (trial) != 1) @@ -3293,7 +3293,7 @@ eligible_for_sibcall_delay (rtx trial) { rtx pat; - if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET) + if (! NONJUMP_INSN_P (trial) || GET_CODE (PATTERN (trial)) != SET) return 0; if (get_attr_length (trial) != 1) @@ -4777,7 +4777,7 @@ sparc_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size) probes at FIRST + N * PROBE_INTERVAL for values of N from 1 until it is equal to ROUNDED_SIZE. */ - if (TARGET_64BIT) + if (TARGET_ARCH64) emit_insn (gen_probe_stack_rangedi (g1, g1, g4)); else emit_insn (gen_probe_stack_rangesi (g1, g1, g4)); @@ -5424,7 +5424,7 @@ sparc_asm_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED) last_real_insn = prev_real_insn (insn); if (last_real_insn - && GET_CODE (last_real_insn) == INSN + && NONJUMP_INSN_P (last_real_insn) && GET_CODE (PATTERN (last_real_insn)) == SEQUENCE) last_real_insn = XVECEXP (PATTERN (last_real_insn), 0, 0); diff --git a/gcc/config/sparc/sparc.md b/gcc/config/sparc/sparc.md index b60af43334c..933991c168d 100644 --- a/gcc/config/sparc/sparc.md +++ b/gcc/config/sparc/sparc.md @@ -7217,7 +7217,7 @@ [(trap_if (match_operator 0 "noov_compare_operator" [(match_operand:SI 1 "compare_operand" "") (match_operand:SI 2 "arith_operand" "")]) - (match_operand 3 ""))] + (match_operand 3 "arith_operand"))] "" "operands[1] = gen_compare_reg (operands[0]); if (GET_MODE (operands[1]) != CCmode && GET_MODE (operands[1]) != CCXmode) @@ -7228,7 +7228,7 @@ [(trap_if (match_operator 0 "noov_compare_operator" [(match_operand:DI 1 "compare_operand" "") (match_operand:DI 2 "arith_operand" "")]) - (match_operand 3 ""))] + (match_operand 3 "arith_operand"))] "TARGET_ARCH64" "operands[1] = gen_compare_reg (operands[0]); if (GET_MODE (operands[1]) != CCmode && GET_MODE (operands[1]) != CCXmode) diff --git a/gcc/config/spu/spu.c b/gcc/config/spu/spu.c index 328bd5bd2ae..2d8ec9c89b2 100644 --- a/gcc/config/spu/spu.c +++ b/gcc/config/spu/spu.c @@ -1962,7 +1962,7 @@ struct spu_bb_info static struct spu_bb_info *spu_bb_info; #define STOP_HINT_P(INSN) \ - (GET_CODE(INSN) == CALL_INSN \ + (CALL_P(INSN) \ || INSN_CODE(INSN) == CODE_FOR_divmodsi4 \ || INSN_CODE(INSN) == CODE_FOR_udivmodsi4) @@ -2163,7 +2163,7 @@ spu_emit_branch_hint (rtx before, rtx branch, rtx target, static rtx get_branch_target (rtx branch) { - if (GET_CODE (branch) == JUMP_INSN) + if (JUMP_P (branch)) { rtx set, src; @@ -2212,7 +2212,7 @@ get_branch_target (rtx branch) return src; } - else if (GET_CODE (branch) == CALL_INSN) + else if (CALL_P (branch)) { rtx call; /* All of our call patterns are in a PARALLEL and the CALL is diff --git a/gcc/config/stormy16/stormy16.c b/gcc/config/stormy16/stormy16.c index 3e20d209a18..30d6d781576 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); @@ -2441,8 +2441,7 @@ combine_bnp (rtx insn) if (reg_mentioned_p (reg, and_insn)) return; - if (GET_CODE (and_insn) != NOTE - && GET_CODE (and_insn) != INSN) + if (! NOTE_P (and_insn) && ! NONJUMP_INSN_P (and_insn)) return; } } @@ -2461,8 +2460,7 @@ combine_bnp (rtx insn) if (reg_mentioned_p (reg, and_insn)) return; - if (GET_CODE (and_insn) != NOTE - && GET_CODE (and_insn) != INSN) + if (! NOTE_P (and_insn) && ! NONJUMP_INSN_P (and_insn)) return; } @@ -2486,8 +2484,7 @@ combine_bnp (rtx insn) break; if (reg_mentioned_p (reg, shift) - || (GET_CODE (shift) != NOTE - && GET_CODE (shift) != INSN)) + || (! NOTE_P (shift) && ! NONJUMP_INSN_P (shift))) { shift = NULL_RTX; break; @@ -2534,8 +2531,7 @@ combine_bnp (rtx insn) if (reg_mentioned_p (reg, load)) return; - if (GET_CODE (load) != NOTE - && GET_CODE (load) != INSN) + if (! NOTE_P (load) && ! NONJUMP_INSN_P (load)) return; } if (!load) diff --git a/gcc/config/tilegx/sync.md b/gcc/config/tilegx/sync.md index a853996162a..a4bea6b6889 100644 --- a/gcc/config/tilegx/sync.md +++ b/gcc/config/tilegx/sync.md @@ -162,3 +162,49 @@ tilegx_post_atomic_barrier (model); DONE; }) + + +(define_expand "atomic_test_and_set" + [(match_operand:QI 0 "register_operand" "") ;; bool output + (match_operand:QI 1 "nonautoincmem_operand" "+U") ;; memory + (match_operand:SI 2 "const_int_operand" "")] ;; model + "" +{ + rtx addr, aligned_addr, aligned_mem, offset, word, shmt; + rtx tmp0, tmp1; + rtx result = operands[0]; + rtx mem = operands[1]; + enum memmodel model = (enum memmodel) INTVAL (operands[2]); + + addr = force_reg (Pmode, XEXP (mem, 0)); + + aligned_addr = gen_reg_rtx (Pmode); + emit_move_insn (aligned_addr, gen_rtx_AND (Pmode, addr, GEN_INT (-8))); + + aligned_mem = change_address (mem, DImode, aligned_addr); + set_mem_alias_set (aligned_mem, 0); + + offset = gen_reg_rtx (DImode); + emit_move_insn (offset, gen_rtx_AND (DImode, gen_lowpart (DImode, addr), + GEN_INT (7))); + + tmp0 = gen_reg_rtx (DImode); + emit_move_insn (tmp0, GEN_INT (1)); + + shmt = gen_reg_rtx (DImode); + emit_move_insn (shmt, gen_rtx_ASHIFT (DImode, offset, GEN_INT (3))); + + word = gen_reg_rtx (DImode); + emit_move_insn (word, gen_rtx_ASHIFT (DImode, tmp0, + gen_lowpart (SImode, shmt))); + + tmp1 = gen_reg_rtx (DImode); + tilegx_pre_atomic_barrier (model); + emit_insn (gen_atomic_fetch_or_baredi (tmp1, aligned_mem, word)); + tilegx_post_atomic_barrier (model); + + emit_move_insn (gen_lowpart (DImode, result), + gen_rtx_LSHIFTRT (DImode, tmp1, + gen_lowpart (SImode, shmt))); + DONE; +}) diff --git a/gcc/config/v850/v850.c b/gcc/config/v850/v850.c index 67cc2c26716..4a746aa1424 100644 --- a/gcc/config/v850/v850.c +++ b/gcc/config/v850/v850.c @@ -1133,13 +1133,13 @@ Saved %d bytes (%d uses of register %s) in function %s, starting as insn %d, end IDENTIFIER_POINTER (DECL_NAME (current_function_decl)), INSN_UID (first_insn), INSN_UID (last_insn)); - if (GET_CODE (first_insn) == NOTE) + if (NOTE_P (first_insn)) first_insn = next_nonnote_insn (first_insn); last_insn = next_nonnote_insn (last_insn); for (insn = first_insn; insn && insn != last_insn; insn = NEXT_INSN (insn)) { - if (GET_CODE (insn) == INSN) + if (NONJUMP_INSN_P (insn)) { rtx pattern = single_set (insn); @@ -1199,7 +1199,7 @@ Saved %d bytes (%d uses of register %s) in function %s, starting as insn %d, end /* Optimize back to back cases of ep <- r1 & r1 <- ep. */ insn = prev_nonnote_insn (first_insn); - if (insn && GET_CODE (insn) == INSN + if (insn && NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SET && SET_DEST (PATTERN (insn)) == *p_ep && SET_SRC (PATTERN (insn)) == *p_r1) diff --git a/gcc/config/xtensa/xtensa.c b/gcc/config/xtensa/xtensa.c index 45929ad515e..7faf7de9968 100644 --- a/gcc/config/xtensa/xtensa.c +++ b/gcc/config/xtensa/xtensa.c @@ -1650,7 +1650,7 @@ xtensa_emit_loop_end (rtx insn, rtx *operands) { rtx body = PATTERN (insn); - if (GET_CODE (body) == JUMP_INSN) + if (JUMP_P (body)) { output_asm_insn (TARGET_DENSITY ? "nop.n" : "nop", operands); done = 1; diff --git a/gcc/configure b/gcc/configure index d4f49bbeceb..eac96cdac70 100755 --- a/gcc/configure +++ b/gcc/configure @@ -23205,6 +23205,18 @@ foo: data8 25 tls_first_minor=13 tls_as_opt=--fatal-warnings ;; + microblaze*-*-*) + conftest_s=' + .section .tdata,"awT",@progbits +x: + .word 2 + .text + addik r5,r20,x@TLSGD + addik r5,r20,x@TLSLDM' + tls_first_major=2 + tls_first_minor=20 + tls_as_opt='--fatal-warnings' + ;; mips*-*-*) conftest_s=' .section .tdata,"awT",@progbits @@ -24632,6 +24644,39 @@ $as_echo "#define HAVE_AS_IX86_SAHF 1" >>confdefs.h fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for interunit movq mnemonic" >&5 +$as_echo_n "checking assembler for interunit movq mnemonic... " >&6; } +if test "${gcc_cv_as_ix86_interunit_movq+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + gcc_cv_as_ix86_interunit_movq=no + if test x$gcc_cv_as != x; then + $as_echo '.code64 + movq %mm0, %rax + movq %rax, %xmm0' > conftest.s + if { ac_try='$gcc_cv_as $gcc_cv_as_flags -o conftest.o conftest.s >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 + (eval $ac_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; } + then + gcc_cv_as_ix86_interunit_movq=yes + else + echo "configure: failed program was" >&5 + cat conftest.s >&5 + fi + rm -f conftest.o conftest.s + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_as_ix86_interunit_movq" >&5 +$as_echo "$gcc_cv_as_ix86_interunit_movq" >&6; } +if test $gcc_cv_as_ix86_interunit_movq = yes; then + +$as_echo "#define HAVE_AS_IX86_INTERUNIT_MOVQ 1" >>confdefs.h + +fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for hle prefixes" >&5 $as_echo_n "checking assembler for hle prefixes... " >&6; } if test "${gcc_cv_as_ix86_hle+set}" = set; then : @@ -25708,6 +25753,37 @@ $as_echo "#define HAVE_AS_GNU_ATTRIBUTE 1" >>confdefs.h fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for .micromips support" >&5 +$as_echo_n "checking assembler for .micromips support... " >&6; } +if test "${gcc_cv_as_micromips_support+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + gcc_cv_as_micromips_support=no + if test x$gcc_cv_as != x; then + $as_echo '.set micromips' > conftest.s + if { ac_try='$gcc_cv_as $gcc_cv_as_flags -o conftest.o conftest.s >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 + (eval $ac_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; } + then + gcc_cv_as_micromips_support=yes + else + echo "configure: failed program was" >&5 + cat conftest.s >&5 + fi + rm -f conftest.o conftest.s + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_as_micromips_support" >&5 +$as_echo "$gcc_cv_as_micromips_support" >&6; } +if test $gcc_cv_as_micromips_support = yes; then + +$as_echo "#define HAVE_GAS_MICROMIPS 1" >>confdefs.h + +fi + { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for .dtprelword support" >&5 $as_echo_n "checking assembler for .dtprelword support... " >&6; } if test "${gcc_cv_as_mips_dtprelword+set}" = set; then : @@ -26274,6 +26350,46 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_ld_eh_frame_hdr" >&5 $as_echo "$gcc_cv_ld_eh_frame_hdr" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking linker CIEv3 in .eh_frame support" >&5 +$as_echo_n "checking linker CIEv3 in .eh_frame support... " >&6; } +gcc_cv_ld_eh_frame_ciev3=no +if test $in_tree_ld = yes ; then + if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \ + && test $in_tree_ld_is_elf = yes; then + gcc_cv_ld_eh_frame_ciev3=yes + fi +elif test x$gcc_cv_ld != x; then + if echo "$ld_ver" | grep GNU > /dev/null; then + gcc_cv_ld_eh_frame_ciev3=yes + if test 0"$ld_date" -lt 20040513; then + if test -n "$ld_date"; then + # If there was date string, but was earlier than 2004-05-13, fail + gcc_cv_ld_eh_frame_ciev3=no + elif test "$ld_vers_major" -lt 2; then + gcc_cv_ld_eh_frame_ciev3=no + elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then + gcc_cv_ld_eh_frame_ciev3=no + fi + fi + else + case "$target" in + *-*-solaris2*) + # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1. + if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then + gcc_cv_ld_eh_frame_ciev3=yes + fi + ;; + esac + fi +fi + +cat >>confdefs.h <<_ACEOF +#define HAVE_LD_EH_FRAME_CIEV3 `if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi` +_ACEOF + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_ld_eh_frame_ciev3" >&5 +$as_echo "$gcc_cv_ld_eh_frame_ciev3" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: checking linker position independent executable support" >&5 $as_echo_n "checking linker position independent executable support... " >&6; } gcc_cv_ld_pie=no diff --git a/gcc/configure.ac b/gcc/configure.ac index 811c296cb81..40a1af7a4a4 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -2968,6 +2968,18 @@ foo: data8 25 tls_first_minor=13 tls_as_opt=--fatal-warnings ;; + microblaze*-*-*) + conftest_s=' + .section .tdata,"awT",@progbits +x: + .word 2 + .text + addik r5,r20,x@TLSGD + addik r5,r20,x@TLSLDM' + tls_first_major=2 + tls_first_minor=20 + tls_as_opt='--fatal-warnings' + ;; mips*-*-*) conftest_s=' .section .tdata,"awT",@progbits @@ -3711,6 +3723,14 @@ foo: nop [AC_DEFINE(HAVE_AS_IX86_SAHF, 1, [Define if your assembler supports the sahf mnemonic in 64bit mode.])]) + gcc_GAS_CHECK_FEATURE([interunit movq mnemonic], + gcc_cv_as_ix86_interunit_movq,,, + [.code64 + movq %mm0, %rax + movq %rax, %xmm0],, + [AC_DEFINE(HAVE_AS_IX86_INTERUNIT_MOVQ, 1, + [Define if your assembler supports interunit movq mnemonic.])]) + gcc_GAS_CHECK_FEATURE([hle prefixes], gcc_cv_as_ix86_hle,,, [lock xacquire cmpxchg %esi, (%ecx)],, @@ -4036,6 +4056,12 @@ LCF0: [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1, [Define if your assembler supports .gnu_attribute.])]) + gcc_GAS_CHECK_FEATURE([.micromips support], + gcc_cv_as_micromips_support,,, + [.set micromips],, + [AC_DEFINE(HAVE_GAS_MICROMIPS, 1, + [Define if your assembler supports the .set micromips directive])]) + gcc_GAS_CHECK_FEATURE([.dtprelword support], gcc_cv_as_mips_dtprelword, [2,18,0],, [.section .tdata,"awT",@progbits @@ -4323,6 +4349,42 @@ if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then fi AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr) +AC_MSG_CHECKING(linker CIEv3 in .eh_frame support) +gcc_cv_ld_eh_frame_ciev3=no +if test $in_tree_ld = yes ; then + if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \ + && test $in_tree_ld_is_elf = yes; then + gcc_cv_ld_eh_frame_ciev3=yes + fi +elif test x$gcc_cv_ld != x; then + if echo "$ld_ver" | grep GNU > /dev/null; then + gcc_cv_ld_eh_frame_ciev3=yes + if test 0"$ld_date" -lt 20040513; then + if test -n "$ld_date"; then + # If there was date string, but was earlier than 2004-05-13, fail + gcc_cv_ld_eh_frame_ciev3=no + elif test "$ld_vers_major" -lt 2; then + gcc_cv_ld_eh_frame_ciev3=no + elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then + gcc_cv_ld_eh_frame_ciev3=no + fi + fi + else + case "$target" in + *-*-solaris2*) + # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1. + if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then + gcc_cv_ld_eh_frame_ciev3=yes + fi + ;; + esac + fi +fi +AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3, + [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`], + [Define 0/1 if your linker supports CIE v3 in .eh_frame.]) +AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3) + AC_MSG_CHECKING(linker position independent executable support) gcc_cv_ld_pie=no if test $in_tree_ld = yes ; then diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index c728c50c587..0a943a13537 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,238 @@ +2013-03-22 Jason Merrill <jason@redhat.com> + + PR c++/56684 + * pt.c (instantiation_dependent_r): Check DECL_INITIAL of VAR_DECL + and CONST_DECL. + +2013-03-21 Gabriel Dos Reis <gdr@integrable-solutions.net> + + * cp-tree.h (identifier_p): New. + * call.c: Throughout, call identifier_p insstead of direct + comparaison of TREE_CODE against IDENTIFIER_NODE. + * decl.c: Likewisse. + * decl2.c: Likewise. + * init.c: Likewise. + * mangle.c: Likewise. + * name-lookup.c: Likewise. + * parser.c: Likewise. + * pt.c: Likewise. + * search.c: Likewise. + * semantics.c: Likewise. + * tree.c: Likewise. + * typeck.c: Likewise. + * typeck2.c: Likewise. + +2013-03-21 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/48087 + * pt.c (convert_nontype_argument): Count werrorcount as warnings. + * call.c (build_temp): Likewise. + * method.c (synthesize_method): Likewise. + * typeck.c (convert_for_initialization): Likewise. + +2013-03-21 Marc Glisse <marc.glisse@inria.fr> + + * call.c (build_conditional_expr_1): Fold VEC_COND_EXPR. + +2013-03-21 Richard Biener <rguenther@suse.de> + + * error.c (cp_printer): Use DECL_HAS_DEBUG_EXPR_P instead of + DECL_DEBUG_EXPR_IS_FROM. Guard properly. + +2013-03-20 Jason Merrill <jason@redhat.com> + + PR c++/56646 + * parser.c (cp_parser_late_return_type_opt): Save and restore + current_class_ptr/ref. + + PR c++/54532 + * expr.c (cplus_expand_constant): Do nothing if the class is + incomplete. + * semantics.c (reduced_constant_expression_p): Allow PTRMEM_CST. + * typeck2.c (store_init_value): Use reduced_constant_expression_p. + * decl.c (maybe_register_incomplete_var): Handle PTRMEM_CST. + (complete_vars): Likewise. + + * name-lookup.c (get_anonymous_namespace_name): Never use + get_file_function_name. + + * pt.c (retrieve_specialization): Handle null tmpl argument. + + PR c++/17232 + PR c++/56642 + * pt.c (tsubst_decl): Check return value of register_specialization. + * typeck2.c (abstract_virtuals_error_sfinae): Re-apply complete_type + change. + +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_expression): 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 + * decl.c (local_variable_p_walkfn): Check DECL_ARTIFICIAL again. + + PR c++/56346 + * decl.c (register_dtor_fn): Pass null to __cxa_thread_atexit + dso_handle parm on targets without __cxa_atexit. + 2013-03-11 Jason Merrill <jason@redhat.com> PR c++/56567 diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 530835b87c8..dd19e48ed18 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -233,7 +233,7 @@ check_dtor_name (tree basetype, tree name) name = TREE_TYPE (name); else if (TYPE_P (name)) /* OK */; - else if (TREE_CODE (name) == IDENTIFIER_NODE) + else if (identifier_p (name)) { if ((MAYBE_CLASS_TYPE_P (basetype) && name == constructor_name (basetype)) @@ -3147,7 +3147,7 @@ print_z_candidate (location_t loc, const char *msgstr, : ACONCAT ((msgstr, " ", NULL))); location_t cloc = location_of (candidate->fn); - if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE) + if (identifier_p (candidate->fn)) { cloc = loc; if (candidate->num_convs == 3) @@ -4437,9 +4437,9 @@ build_conditional_expr_1 (tree arg1, tree arg2, tree arg3, } if (!COMPARISON_CLASS_P (arg1)) - arg1 = build2 (NE_EXPR, signed_type_for (arg1_type), arg1, + arg1 = fold_build2 (NE_EXPR, signed_type_for (arg1_type), arg1, build_zero_cst (arg1_type)); - return build3 (VEC_COND_EXPR, arg2_type, arg1, arg2, arg3); + return fold_build3 (VEC_COND_EXPR, arg2_type, arg1, arg2, arg3); } /* [expr.cond] @@ -5709,12 +5709,12 @@ build_temp (tree expr, tree type, int flags, int savew, savee; vec<tree, va_gc> *args; - savew = warningcount, savee = errorcount; + savew = warningcount + werrorcount, savee = errorcount; args = make_tree_vector_single (expr); expr = build_special_member_call (NULL_TREE, complete_ctor_identifier, &args, type, flags, complain); release_tree_vector (args); - if (warningcount > savew) + if (warningcount + werrorcount > savew) *diagnostic_kind = DK_WARNING; else if (errorcount > savee) *diagnostic_kind = DK_ERROR; @@ -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); } @@ -8554,8 +8563,7 @@ joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn, - do not have the same parameter type list as any non-template non-member candidate. */ - if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE - || TREE_CODE (cand2->fn) == IDENTIFIER_NODE) + if (identifier_p (cand1->fn) || identifier_p (cand2->fn)) { for (i = 0; i < len; ++i) if (!same_type_p (cand1->convs[i]->type, @@ -8566,7 +8574,7 @@ joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn, if (cand1->fn == cand2->fn) /* Two built-in candidates; arbitrarily pick one. */ return 1; - else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE) + else if (identifier_p (cand1->fn)) /* cand1 is built-in; prefer cand2. */ return -1; else 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..401868549cd 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -241,6 +241,16 @@ struct GTY(()) lang_identifier { tree label_value; }; +/* Return a typed pointer version of T if it designates a + C++ front-end identifier. */ +inline lang_identifier* +identifier_p (tree t) +{ + if (TREE_CODE (t) == IDENTIFIER_NODE) + return (lang_identifier*) t; + return NULL; +} + /* In an IDENTIFIER_NODE, nonzero if this identifier is actually a keyword. C_RID_CODE (node) is then the RID_* value of the keyword, and C_RID_YYCODE is the token number wanted by Yacc. */ @@ -463,6 +473,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 +1230,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 +4216,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 +4288,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 +6012,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 150e8662a5e..ea1a08d2674 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -3296,7 +3296,7 @@ make_typename_type (tree context, tree name, enum tag_types tag_type, error ("%qD used without template parameters", name); return error_mark_node; } - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (identifier_p (name)); gcc_assert (TYPE_P (context)); if (!MAYBE_CLASS_TYPE_P (context)) @@ -3402,7 +3402,7 @@ make_unbound_class_template (tree context, tree name, tree parm_list, name = TYPE_IDENTIFIER (name); else if (DECL_P (name)) name = DECL_NAME (name); - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (identifier_p (name)); if (!dependent_type_p (context) || currently_open_class (context)) @@ -4781,7 +4781,7 @@ check_array_designated_initializer (const constructor_elt *ce, } else { - gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE); + gcc_assert (identifier_p (ce->index)); error ("name %qD used in a GNU-style designated " "initializer for an array", ce->index); } @@ -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. */ @@ -6758,10 +6754,9 @@ register_dtor_fn (tree decl) "__aeabi_atexit"), and DECL is a class object, we can just pass the destructor to "__cxa_atexit"; we don't have to build a temporary function to do the cleanup. */ - ob_parm = (DECL_THREAD_LOCAL_P (decl) - || (flag_use_cxa_atexit - && !targetm.cxx.use_atexit_for_cxa_atexit ())); - dso_parm = ob_parm; + dso_parm = (flag_use_cxa_atexit + && !targetm.cxx.use_atexit_for_cxa_atexit ()); + ob_parm = (DECL_THREAD_LOCAL_P (decl) || dso_parm); use_dtor = ob_parm && CLASS_TYPE_P (type); if (use_dtor) { @@ -6825,7 +6820,7 @@ register_dtor_fn (tree decl) before passing it in, to avoid spurious errors. */ addr = build_nop (ptr_type_node, addr); } - else if (ob_parm) + else /* Since the cleanup functions we build ignore the address they're given, there's no reason to pass the actual address in, and, in general, it's cheaper to pass NULL than any @@ -6835,6 +6830,10 @@ register_dtor_fn (tree decl) if (dso_parm) arg2 = cp_build_addr_expr (get_dso_handle_node (), tf_warning_or_error); + else if (ob_parm) + /* Just pass NULL to the dso handle parm if we don't actually + have a DSO handle on this target. */ + arg2 = null_pointer_node; else arg2 = NULL_TREE; @@ -7414,8 +7413,7 @@ grokfndecl (tree ctype, == current_class_type); fns = TREE_OPERAND (fns, 1); } - gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE - || TREE_CODE (fns) == OVERLOAD); + gcc_assert (identifier_p (fns) || TREE_CODE (fns) == OVERLOAD); DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args); for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t)) @@ -7773,7 +7771,7 @@ grokvardecl (tree type, tree decl; tree explicit_scope; - gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (!name || identifier_p (name)); /* Compute the scope in which to place the variable, but remember whether or not that scope was explicitly specified by the user. */ @@ -8510,7 +8508,7 @@ check_var_type (tree identifier, tree type) { if (!identifier) error ("unnamed variable or field declared void"); - else if (TREE_CODE (identifier) == IDENTIFIER_NODE) + else if (identifier_p (identifier)) { gcc_assert (!IDENTIFIER_OPNAME_P (identifier)); error ("variable or field %qE declared void", identifier); @@ -8653,6 +8651,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); @@ -8778,7 +8777,7 @@ grokdeclarator (const cp_declarator *declarator, tree fns = TREE_OPERAND (decl, 0); dname = fns; - if (TREE_CODE (dname) != IDENTIFIER_NODE) + if (!identifier_p (dname)) { gcc_assert (is_overloaded_fn (dname)); dname = DECL_NAME (get_first_fn (dname)); @@ -8787,7 +8786,7 @@ grokdeclarator (const cp_declarator *declarator, /* Fall through. */ case IDENTIFIER_NODE: - if (TREE_CODE (decl) == IDENTIFIER_NODE) + if (identifier_p (decl)) dname = decl; if (C_IS_RESERVED_WORD (dname)) @@ -8852,7 +8851,7 @@ grokdeclarator (const cp_declarator *declarator, } if (dname - && TREE_CODE (dname) == IDENTIFIER_NODE + && identifier_p (dname) && UDLIT_OPER_P (dname) && innermost_code != cdk_function) { @@ -8977,7 +8976,7 @@ grokdeclarator (const cp_declarator *declarator, common. With no options, it is allowed. With -Wreturn-type, it is a warning. It is only an error with -pedantic-errors. */ is_main = (funcdef_flag - && dname && TREE_CODE (dname) == IDENTIFIER_NODE + && dname && identifier_p (dname) && MAIN_NAME_P (dname) && ctype == NULL_TREE && in_namespace == NULL_TREE @@ -9337,7 +9336,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; @@ -9425,11 +9423,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; @@ -9632,9 +9629,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, @@ -10800,9 +10799,8 @@ static tree local_variable_p_walkfn (tree *tp, int *walk_subtrees, void * /*data*/) { - /* Check DECL_NAME to avoid including temporaries. We don't check - DECL_ARTIFICIAL because we do want to complain about 'this'. */ - if (local_variable_p (*tp) && DECL_NAME (*tp)) + if (local_variable_p (*tp) + && (!DECL_ARTIFICIAL (*tp) || DECL_NAME (*tp) == this_identifier)) return *tp; else if (TYPE_P (*tp)) *walk_subtrees = 0; @@ -11890,13 +11888,14 @@ 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); + gcc_assert (identifier_p (name)); switch (tag_code) { @@ -11914,6 +11913,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)) @@ -11987,6 +11991,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); } } @@ -12314,7 +12322,7 @@ start_enum (tree name, tree enumtype, tree underlying_type, bool scoped_enum_p, bool *is_new) { tree prevtype = NULL_TREE; - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (identifier_p (name)); if (is_new) *is_new = false; @@ -14009,7 +14017,10 @@ grokmethod (cp_decl_specifier_seq *declspecs, /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that - we can lay it out later, when and if its type becomes complete. */ + we can lay it out later, when and if its type becomes complete. + + Also handle constexpr pointer to member variables where the initializer + is an unlowered PTRMEM_CST because the class isn't complete yet. */ void maybe_register_incomplete_var (tree var) @@ -14034,6 +14045,15 @@ maybe_register_incomplete_var (tree var) incomplete_var iv = {var, inner_type}; vec_safe_push (incomplete_vars, iv); } + else if (TYPE_PTRMEM_P (inner_type) + && DECL_INITIAL (var) + && TREE_CODE (DECL_INITIAL (var)) == PTRMEM_CST) + { + tree context = TYPE_PTRMEM_CLASS_TYPE (inner_type); + gcc_assert (TYPE_BEING_DEFINED (context)); + incomplete_var iv = {var, context}; + vec_safe_push (incomplete_vars, iv); + } } } @@ -14053,10 +14073,17 @@ complete_vars (tree type) { tree var = iv->decl; tree type = TREE_TYPE (var); - /* Complete the type of the variable. The VAR_DECL itself - will be laid out in expand_expr. */ - complete_type (type); - cp_apply_type_quals_to_decl (cp_type_quals (type), var); + + if (TYPE_PTRMEM_P (type)) + DECL_INITIAL (var) = cplus_expand_constant (DECL_INITIAL (var)); + else + { + /* Complete the type of the variable. The VAR_DECL itself + will be laid out in expand_expr. */ + complete_type (type); + cp_apply_type_quals_to_decl (cp_type_quals (type), var); + } + /* Remove this entry from the list. */ incomplete_vars->unordered_remove (ix); } diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 82bc6f79e5b..f13efd67da9 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -1121,7 +1121,7 @@ is_late_template_attribute (tree attr, tree decl) second and following arguments. Attributes like mode, format, cleanup and several target specific attributes aren't late just because they have an IDENTIFIER_NODE as first argument. */ - if (arg == args && TREE_CODE (t) == IDENTIFIER_NODE) + if (arg == args && identifier_p (t)) continue; if (value_dependent_expression_p (t) diff --git a/gcc/cp/error.c b/gcc/cp/error.c index c2bf54dcb2c..bcb0274c1b6 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; @@ -3275,8 +3283,8 @@ cp_printer (pretty_printer *pp, text_info *text, const char *spec, case 'D': { tree temp = next_tree; - if (DECL_P (temp) - && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp)) + if (TREE_CODE (temp) == VAR_DECL + && DECL_HAS_DEBUG_EXPR_P (temp)) { temp = DECL_DEBUG_EXPR (temp); if (!DECL_P (temp)) 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/expr.c b/gcc/cp/expr.c index ffd18ca6785..f15b049baf8 100644 --- a/gcc/cp/expr.c +++ b/gcc/cp/expr.c @@ -43,6 +43,10 @@ cplus_expand_constant (tree cst) /* Find the member. */ member = PTRMEM_CST_MEMBER (cst); + /* We can't lower this until the class is complete. */ + if (!COMPLETE_TYPE_P (DECL_CONTEXT (member))) + return cst; + if (TREE_CODE (member) == FIELD_DECL) { /* Find the offset for the field. */ diff --git a/gcc/cp/init.c b/gcc/cp/init.c index 697f11ff52e..32f242c3275 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -1416,7 +1416,7 @@ expand_member_init (tree name) } else { - if (TREE_CODE (name) == IDENTIFIER_NODE) + if (identifier_p (name)) field = lookup_field (current_class_type, name, 1, false); else field = name; @@ -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/mangle.c b/gcc/cp/mangle.c index a48d476856c..603f7019a70 100644 --- a/gcc/cp/mangle.c +++ b/gcc/cp/mangle.c @@ -1189,7 +1189,7 @@ write_unqualified_name (const tree decl) { MANGLE_TRACE_TREE ("unqualified-name", decl); - if (TREE_CODE (decl) == IDENTIFIER_NODE) + if (identifier_p (decl)) { write_unqualified_id (decl); return; @@ -2519,7 +2519,7 @@ write_template_args (tree args) static void write_member_name (tree member) { - if (TREE_CODE (member) == IDENTIFIER_NODE) + if (identifier_p (member)) write_unqualified_id (member); else if (DECL_P (member)) write_unqualified_name (member); @@ -2697,7 +2697,7 @@ write_expression (tree expr) { write_expression (TREE_OPERAND (expr, 0)); } - else if (TREE_CODE (expr) == IDENTIFIER_NODE) + else if (identifier_p (expr)) { /* An operator name appearing as a dependent name needs to be specially marked to disambiguate between a use of the operator diff --git a/gcc/cp/method.c b/gcc/cp/method.c index ff29b596892..316c5d3b8eb 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -755,7 +755,7 @@ synthesize_method (tree fndecl) tree stmt; location_t save_input_location = input_location; int error_count = errorcount; - int warning_count = warningcount; + int warning_count = warningcount + werrorcount; /* Reset the source location, we might have been previously deferred, and thus have saved where we were first needed. */ @@ -817,7 +817,7 @@ synthesize_method (tree fndecl) pop_deferring_access_checks (); - if (error_count != errorcount || warning_count != warningcount) + if (error_count != errorcount || warning_count != warningcount + werrorcount) inform (input_location, "synthesized method %qD first required here ", fndecl); } @@ -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.c b/gcc/cp/name-lookup.c index 2a47331ea73..dd6ef223def 100644 --- a/gcc/cp/name-lookup.c +++ b/gcc/cp/name-lookup.c @@ -69,14 +69,12 @@ get_anonymous_namespace_name (void) { if (!anonymous_namespace_name) { - /* The anonymous namespace has to have a unique name - if typeinfo objects are being compared by name. */ - if (! flag_weak || ! SUPPORTS_ONE_ONLY) - anonymous_namespace_name = get_file_function_name ("N"); - else - /* The demangler expects anonymous namespaces to be called - something starting with '_GLOBAL__N_'. */ - anonymous_namespace_name = get_identifier ("_GLOBAL__N_1"); + /* We used to use get_file_function_name here, but that isn't + necessary now that anonymous namespace typeinfos + are !TREE_PUBLIC, and thus compared by address. */ + /* The demangler expects anonymous namespaces to be called + something starting with '_GLOBAL__N_'. */ + anonymous_namespace_name = get_identifier ("_GLOBAL__N_1"); } return anonymous_namespace_name; } @@ -1961,7 +1959,7 @@ constructor_name_p (tree name, tree type) if (!name) return false; - if (TREE_CODE (name) != IDENTIFIER_NODE) + if (!identifier_p (name)) return false; /* These don't have names. */ @@ -2075,7 +2073,7 @@ lookup_extern_c_fun_in_all_ns (tree function) gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL); name = DECL_NAME (function); - gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (name && identifier_p (name)); for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter; @@ -2138,7 +2136,7 @@ push_using_decl_1 (tree scope, tree name) tree decl; gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL); - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (identifier_p (name)); for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl)) if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name) break; @@ -5726,7 +5724,7 @@ pushtag_1 (tree name, tree type, tag_scope scope) || COMPLETE_TYPE_P (b->this_entity)))) b = b->level_chain; - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (identifier_p (name)); /* Do C++ gratuitous typedefing. */ if (identifier_type_value_1 (name) != type) 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..7ac90df1671 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -1110,7 +1110,7 @@ cp_lexer_print_token (FILE * stream, cp_token *token) case CPP_KEYWORD: /* Some keywords have a value that is not an IDENTIFIER_NODE. For example, `struct' is mapped to an INTEGER_CST. */ - if (TREE_CODE (token->u.value) != IDENTIFIER_NODE) + if (!identifier_p (token->u.value)) break; /* else fall through */ case CPP_NAME: @@ -1259,7 +1259,7 @@ make_id_declarator (tree qualifying_scope, tree unqualified_name, if (qualifying_scope && TYPE_P (qualifying_scope)) qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope); - gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE + gcc_assert (identifier_p (unqualified_name) || TREE_CODE (unqualified_name) == BIT_NOT_EXPR || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR); @@ -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 @@ -2585,7 +2587,7 @@ cp_parser_check_for_invalid_template_id (cp_parser* parser, { if (TYPE_P (type)) error_at (location, "%qT is not a template", type); - else if (TREE_CODE (type) == IDENTIFIER_NODE) + else if (identifier_p (type)) { if (tag_type != none_type) error_at (location, "%qE is not a class template", type); @@ -3191,7 +3193,7 @@ cp_parser_make_typename_type (cp_parser *parser, tree scope, tree id, location_t id_location) { tree result; - if (TREE_CODE (id) == IDENTIFIER_NODE) + if (identifier_p (id)) { result = make_typename_type (scope, id, typename_type, /*complain=*/tf_none); @@ -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,16 +5639,22 @@ 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) { if (idk == CP_ID_KIND_UNQUALIFIED - && TREE_CODE (postfix_expression) == IDENTIFIER_NODE + && identifier_p (postfix_expression) && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)) /* It is not a Koenig lookup function call. */ postfix_expression @@ -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 @@ -5718,7 +5741,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, if (idk == CP_ID_KIND_UNQUALIFIED || idk == CP_ID_KIND_TEMPLATE_ID) { - if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE) + if (identifier_p (postfix_expression)) { if (!args->is_empty ()) { @@ -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 @@ -11242,7 +11310,7 @@ cp_parser_decltype (cp_parser *parser) cp_id_kind idk; const char *error_msg; - if (TREE_CODE (expr) == IDENTIFIER_NODE) + if (identifier_p (expr)) /* Lookup the name we got back from the id-expression. */ expr = cp_parser_lookup_name (parser, expr, none_type, @@ -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. */ @@ -12690,7 +12759,7 @@ cp_parser_template_id (cp_parser *parser, } /* Build a representation of the specialization. */ - if (TREE_CODE (templ) == IDENTIFIER_NODE) + if (identifier_p (templ)) template_id = build_min_nt_loc (next_token->location, TEMPLATE_ID_EXPR, templ, arguments); @@ -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)) @@ -13912,7 +13980,7 @@ cp_parser_simple_type_specifier (cp_parser* parser, && !global_p && !qualified_p && TREE_CODE (type) == TYPE_DECL - && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE) + && identifier_p (DECL_NAME (type))) maybe_note_name_used_in_class (DECL_NAME (type), type); /* If it didn't work out, we don't have a TYPE. */ if ((flags & CP_PARSER_FLAGS_OPTIONAL) @@ -15211,7 +15279,7 @@ cp_parser_using_declaration (cp_parser* parser, depending on what scope we are in. */ if (qscope == error_mark_node || identifier == error_mark_node) ; - else if (TREE_CODE (identifier) != IDENTIFIER_NODE + else if (!identifier_p (identifier) && TREE_CODE (identifier) != BIT_NOT_EXPR) /* [namespace.udecl] @@ -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); @@ -16492,8 +16562,7 @@ cp_parser_direct_declarator (cp_parser* parser, unqualified_name = error_mark_node; else if (unqualified_name && (qualifying_scope - || (TREE_CODE (unqualified_name) - != IDENTIFIER_NODE))) + || (!identifier_p (unqualified_name)))) { cp_parser_error (parser, "expected unqualified-id"); unqualified_name = error_mark_node; @@ -16637,9 +16706,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 +17017,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 @@ -16964,17 +17055,21 @@ cp_parser_late_return_type_opt (cp_parser* parser, cp_cv_quals quals) /* Consume the ->. */ cp_lexer_consume_token (parser->lexer); + tree save_ccp = current_class_ptr; + tree save_ccr = current_class_ref; if (quals >= 0) { /* DR 1207: 'this' is in scope in the trailing return type. */ - gcc_assert (current_class_ptr == NULL_TREE); inject_this_parameter (current_class_type, quals); } type = cp_parser_trailing_type_id (parser); if (quals >= 0) - current_class_ptr = current_class_ref = NULL_TREE; + { + current_class_ptr = save_ccp; + current_class_ref = save_ccr; + } return type; } @@ -18130,7 +18225,7 @@ cp_parser_class_name (cp_parser *parser, /* Check to see that it is really the name of a class. */ if (TREE_CODE (decl) == TEMPLATE_ID_EXPR - && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE + && identifier_p (TREE_OPERAND (decl, 0)) && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)) /* Situations like this: @@ -21024,7 +21119,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name, /* By this point, the NAME should be an ordinary identifier. If the id-expression was a qualified name, the qualifying scope is stored in PARSER->SCOPE at this point. */ - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (identifier_p (name)); /* Perform the lookup. */ if (parser->scope) @@ -22033,7 +22128,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 @@ -24194,7 +24289,7 @@ cp_parser_objc_protocol_qualifiers (cp_parser* parser) node = token->u.value; - while (node && TREE_CODE (node) == IDENTIFIER_NODE + while (node && identifier_p (node) && (node == ridpointers [(int) RID_IN] || node == ridpointers [(int) RID_OUT] || node == ridpointers [(int) RID_INOUT] @@ -26830,7 +26925,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..b6066c18bde 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -1009,6 +1009,9 @@ optimize_specialization_lookup_p (tree tmpl) static tree retrieve_specialization (tree tmpl, tree args, hashval_t hash) { + if (tmpl == NULL_TREE) + return NULL_TREE; + if (args == error_mark_node) return NULL_TREE; @@ -2464,7 +2467,7 @@ check_explicit_specialization (tree declarator, { tree fns; - gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE); + gcc_assert (identifier_p (declarator)); if (ctype) fns = dname; else @@ -2525,8 +2528,7 @@ check_explicit_specialization (tree declarator, return decl; } else if (ctype != NULL_TREE - && (TREE_CODE (TREE_OPERAND (declarator, 0)) == - IDENTIFIER_NODE)) + && (identifier_p (TREE_OPERAND (declarator, 0)))) { /* Find the list of functions in ctype that have the same name as the declared function. */ @@ -4306,6 +4308,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 +4683,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 +5055,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 +5564,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 @@ -5586,12 +5600,12 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain) { if (complain & tf_error) { - int errs = errorcount, warns = warningcount; + int errs = errorcount, warns = warningcount + werrorcount; if (processing_template_decl && !require_potential_constant_expression (expr)) return NULL_TREE; expr = cxx_constant_value (expr); - if (errorcount > errs || warningcount > warns) + if (errorcount > errs || warningcount + werrorcount > warns) inform (EXPR_LOC_OR_HERE (expr), "in template argument for type %qT ", type); if (expr == error_mark_node) @@ -5641,6 +5655,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 +5809,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; @@ -6933,7 +6954,7 @@ lookup_template_function (tree fns, tree arglist) gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC); - if (!is_overloaded_fn (fns) && TREE_CODE (fns) != IDENTIFIER_NODE) + if (!is_overloaded_fn (fns) && !identifier_p (fns)) { error ("%q#D is not a function template", fns); return error_mark_node; @@ -7036,7 +7057,7 @@ lookup_template_class_1 (tree d1, tree arglist, tree in_decl, tree context, spec_entry elt; hashval_t hash; - if (TREE_CODE (d1) == IDENTIFIER_NODE) + if (identifier_p (d1)) { tree value = innermost_non_namespace_value (d1); if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value)) @@ -7831,7 +7852,7 @@ uses_template_parms (tree t) || TREE_CODE (t) == TEMPLATE_PARM_INDEX || TREE_CODE (t) == OVERLOAD || BASELINK_P (t) - || TREE_CODE (t) == IDENTIFIER_NODE + || identifier_p (t) || TREE_CODE (t) == TRAIT_EXPR || TREE_CODE (t) == CONSTRUCTOR || CONSTANT_CLASS_P (t)) @@ -8460,8 +8481,7 @@ apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags, if (TREE_VALUE (t) && TREE_CODE (TREE_VALUE (t)) == TREE_LIST && TREE_VALUE (TREE_VALUE (t)) - && (TREE_CODE (TREE_VALUE (TREE_VALUE (t))) - == IDENTIFIER_NODE)) + && (identifier_p (TREE_VALUE (TREE_VALUE (t))))) { tree chain = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args, complain, @@ -8992,12 +9012,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 @@ -10252,7 +10286,13 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) DECL_TEMPLATE_INFO (r) = build_template_info (gen_tmpl, argvec); SET_DECL_IMPLICIT_INSTANTIATION (r); - register_specialization (r, gen_tmpl, argvec, false, hash); + + tree new_r + = register_specialization (r, gen_tmpl, argvec, false, hash); + if (new_r != r) + /* We instantiated this while substituting into + the type earlier (template/friend54.C). */ + RETURN (new_r); /* We're not supposed to instantiate default arguments until they are called, for a template. But, for a @@ -10826,6 +10866,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 +10931,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 +10945,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 +11669,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 +11797,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 +12050,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 +13433,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: @@ -13432,7 +13478,7 @@ tsubst_copy_and_build (tree t, input_location); if (error_msg) error (error_msg); - if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE) + if (!function_p && identifier_p (decl)) { if (complain & tf_error) unqualified_name_lookup_error (decl); @@ -13824,10 +13870,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 +13890,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. */ @@ -13849,7 +13905,7 @@ tsubst_copy_and_build (tree t, /*done=*/false, /*address_p=*/false); } - else if (koenig_p && TREE_CODE (function) == IDENTIFIER_NODE) + else if (koenig_p && identifier_p (function)) { /* Do nothing; calling tsubst_copy_and_build on an identifier would incorrectly perform unqualified lookup again. @@ -13933,7 +13989,7 @@ tsubst_copy_and_build (tree t, not appropriate, even if an unqualified-name was used to denote the function. */ && !DECL_FUNCTION_MEMBER_P (get_first_fn (function))) - || TREE_CODE (function) == IDENTIFIER_NODE) + || identifier_p (function)) /* Only do this when substitution turns a dependent call into a non-dependent call. */ && type_dependent_expression_p_push (t) @@ -13941,7 +13997,7 @@ tsubst_copy_and_build (tree t, function = perform_koenig_lookup (function, call_args, false, tf_none); - if (TREE_CODE (function) == IDENTIFIER_NODE + if (identifier_p (function) && !any_type_dependent_arguments_p (call_args)) { if (koenig_p && (complain & tf_warning_or_error)) @@ -13991,7 +14047,7 @@ tsubst_copy_and_build (tree t, function = unq; } } - if (TREE_CODE (function) == IDENTIFIER_NODE) + if (identifier_p (function)) { if (complain & tf_error) unqualified_name_lookup_error (function); @@ -14004,6 +14060,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 +14530,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)); @@ -19726,8 +19779,7 @@ type_dependent_expression_p (tree expression) return false; /* An unresolved name is always dependent. */ - if (TREE_CODE (expression) == IDENTIFIER_NODE - || TREE_CODE (expression) == USING_DECL) + if (identifier_p (expression) || TREE_CODE (expression) == USING_DECL) return true; /* Some expression forms are never type-dependent. */ @@ -19832,7 +19884,7 @@ type_dependent_expression_p (tree expression) if (type_dependent_expression_p (TREE_OPERAND (expression, 0))) return true; expression = TREE_OPERAND (expression, 1); - if (TREE_CODE (expression) == IDENTIFIER_NODE) + if (identifier_p (expression)) return false; } /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */ @@ -19890,6 +19942,13 @@ instantiation_dependent_r (tree *tp, int *walk_subtrees, case TREE_VEC: return NULL_TREE; + case VAR_DECL: + case CONST_DECL: + /* A constant with a dependent initializer is dependent. */ + if (value_dependent_expression_p (*tp)) + return *tp; + break; + case TEMPLATE_PARM_INDEX: return *tp; @@ -19923,7 +19982,7 @@ instantiation_dependent_r (tree *tp, int *walk_subtrees, return NULL_TREE; case COMPONENT_REF: - if (TREE_CODE (TREE_OPERAND (*tp, 1)) == IDENTIFIER_NODE) + if (identifier_p (TREE_OPERAND (*tp, 1))) /* In a template, finish_class_member_access_expr creates a COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't type-dependent, so that we can check access control at @@ -20167,8 +20226,7 @@ dependent_template_p (tree tmpl) || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM) return true; /* So are names that have not been looked up. */ - if (TREE_CODE (tmpl) == SCOPE_REF - || TREE_CODE (tmpl) == IDENTIFIER_NODE) + if (TREE_CODE (tmpl) == SCOPE_REF || identifier_p (tmpl)) return true; /* So are member templates of dependent classes. */ if (TYPE_P (CP_DECL_CONTEXT (tmpl))) @@ -20325,7 +20383,7 @@ resolve_typename_type (tree type, bool only_current_p) find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */ if (!decl) /*nop*/; - else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE + else if (identifier_p (TYPENAME_TYPE_FULLNAME (type)) && TREE_CODE (decl) == TYPE_DECL) { result = TREE_TYPE (decl); diff --git a/gcc/cp/search.c b/gcc/cp/search.c index 4cc02ba7dfc..0ac7cdc2767 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) @@ -373,7 +381,7 @@ lookup_field_1 (tree type, tree name, bool want_type) { tree field; - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (identifier_p (name)); if (TREE_CODE (type) == TEMPLATE_TYPE_PARM || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM @@ -1182,7 +1190,7 @@ lookup_member (tree xbasetype, tree name, int protect, bool want_type, || xbasetype == error_mark_node) return NULL_TREE; - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); + gcc_assert (identifier_p (name)); if (TREE_CODE (xbasetype) == TREE_BINFO) { diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index e909b984681..e3aeb817a52 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -536,7 +536,7 @@ simplify_loop_decl_cond (tree *cond_p, tree body) tree finish_goto_stmt (tree destination) { - if (TREE_CODE (destination) == IDENTIFIER_NODE) + if (identifier_p (destination)) destination = lookup_label (destination); /* We warn about unused labels with -Wunused. That means we have to @@ -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; @@ -2001,7 +1999,7 @@ perform_koenig_lookup (tree fn, vec<tree, va_gc> *args, bool include_std, } /* Find the name of the overloaded function. */ - if (TREE_CODE (fn) == IDENTIFIER_NODE) + if (identifier_p (fn)) identifier = fn; else if (is_overloaded_fn (fn)) { @@ -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. */ @@ -2967,7 +2966,7 @@ finish_id_expression (tree id_expression, if (scope && (!TYPE_P (scope) || (!dependent_type_p (scope) - && !(TREE_CODE (id_expression) == IDENTIFIER_NODE + && !(identifier_p (id_expression) && IDENTIFIER_TYPENAME_P (id_expression) && dependent_type_p (TREE_TYPE (id_expression)))))) { @@ -2996,8 +2995,7 @@ finish_id_expression (tree id_expression, the current class so that we can check later to see if the meaning would have been different after the class was entirely defined. */ - if (!scope && decl != error_mark_node - && TREE_CODE (id_expression) == IDENTIFIER_NODE) + if (!scope && decl != error_mark_node && identifier_p (id_expression)) maybe_note_name_used_in_class (id_expression, decl); /* Disallow uses of local variables from containing functions, except @@ -3041,12 +3039,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)); @@ -3168,8 +3168,7 @@ finish_id_expression (tree id_expression, /* A template-id where the name of the template was not resolved is definitely dependent. */ else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR - && (TREE_CODE (TREE_OPERAND (decl, 0)) - == IDENTIFIER_NODE)) + && (identifier_p (TREE_OPERAND (decl, 0)))) dependent_p = true; /* For anything except an overloaded function, just check its type. */ @@ -5300,7 +5299,7 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p, [expr.ref]), decltype(e) is defined as the type of the entity named by e. If there is no such entity, or e names a set of overloaded functions, the program is ill-formed. */ - if (TREE_CODE (expr) == IDENTIFIER_NODE) + if (identifier_p (expr)) expr = lookup_name (expr); if (TREE_CODE (expr) == INDIRECT_REF) @@ -6837,6 +6836,9 @@ cxx_eval_call_expression (const constexpr_call *old_call, tree t, bool reduced_constant_expression_p (tree t) { + if (TREE_CODE (t) == PTRMEM_CST) + /* Even if we can't lower this yet, it's constant. */ + return true; /* FIXME are we calling this too much? */ return initializer_constant_valid_p (t, TREE_TYPE (t)) != NULL_TREE; } @@ -7007,6 +7009,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 +8496,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 +8983,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 +9055,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 +9264,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 +9677,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..3cfc8690d89 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; @@ -1730,7 +1734,7 @@ is_overloaded_fn (tree x) tree dependent_name (tree x) { - if (TREE_CODE (x) == IDENTIFIER_NODE) + if (identifier_p (x)) return x; if (TREE_CODE (x) != COMPONENT_REF && TREE_CODE (x) != OFFSET_REF @@ -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..4e42a9d3d7b 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -2467,7 +2467,7 @@ lookup_destructor (tree object, tree scope, tree dtor_name) scope, dtor_type); return error_mark_node; } - if (TREE_CODE (dtor_type) == IDENTIFIER_NODE) + if (identifier_p (dtor_type)) { /* In a template, names we can't find a match for are still accepted destructor names, and we check them here. */ @@ -2588,7 +2588,7 @@ finish_class_member_access_expr (tree object, tree name, bool template_p, dependent_type_p (object_type) /* If NAME is just an IDENTIFIER_NODE, then the expression is dependent. */ - || TREE_CODE (object) == IDENTIFIER_NODE + || identifier_p (object) /* If NAME is "f<args>", where either 'f' or 'args' is dependent, then the expression is dependent. */ || (TREE_CODE (name) == TEMPLATE_ID_EXPR @@ -2604,7 +2604,7 @@ finish_class_member_access_expr (tree object, tree name, bool template_p, object = build_non_dependent_expr (object); } else if (c_dialect_objc () - && TREE_CODE (name) == IDENTIFIER_NODE + && identifier_p (name) && (expr = objc_maybe_build_component_ref (object, name))) return expr; @@ -2671,8 +2671,7 @@ finish_class_member_access_expr (tree object, tree name, bool template_p, } gcc_assert (CLASS_TYPE_P (scope)); - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE - || TREE_CODE (name) == BIT_NOT_EXPR); + gcc_assert (identifier_p (name) || TREE_CODE (name) == BIT_NOT_EXPR); if (constructor_name_p (name, scope)) { @@ -4015,7 +4014,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 +4050,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 @@ -5067,8 +5066,7 @@ cp_build_addr_expr_1 (tree arg, bool strict_lvalue, tsubst_flags_t complain) arg = mark_lvalue_use (arg); argtype = lvalue_type (arg); - gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE - || !IDENTIFIER_OPNAME_P (arg)); + gcc_assert (!identifier_p (arg) || !IDENTIFIER_OPNAME_P (arg)); if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg) && !really_overloaded_fn (TREE_OPERAND (arg, 1))) @@ -6238,6 +6236,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 @@ -7971,11 +7975,11 @@ convert_for_initialization (tree exp, tree type, tree rhs, int flags, int savew = 0, savee = 0; if (fndecl) - savew = warningcount, savee = errorcount; + savew = warningcount + werrorcount, savee = errorcount; rhs = initialize_reference (type, rhs, flags, complain); if (fndecl) { - if (warningcount > savew) + if (warningcount + werrorcount > savew) warning (0, "in passing argument %P of %q+D", parmnum, fndecl); else if (errorcount > savee) error ("in passing argument %P of %q+D", parmnum, fndecl); diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index d227a821d43..ca31610d66b 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; @@ -258,6 +265,10 @@ abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) return 0; type = TYPE_MAIN_VARIANT (type); + /* In SFINAE context, force instantiation. */ + if (!(complain & tf_error)) + complete_type (type); + /* If the type is incomplete, we register it within a hash table, so that we can check again once it is completed. This makes sense only for objects for which we have a declaration or at least a @@ -267,8 +278,7 @@ abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) void **slot; struct pending_abstract_type *pat; - gcc_assert (!decl || DECL_P (decl) - || TREE_CODE (decl) == IDENTIFIER_NODE); + gcc_assert (!decl || DECL_P (decl) || identifier_p (decl)); if (!abstract_pending_vars) abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash, @@ -280,6 +290,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 +319,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); @@ -318,14 +335,40 @@ abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain) error ("invalid abstract return type for member function %q+#D", decl); else if (TREE_CODE (decl) == FUNCTION_DECL) error ("invalid abstract return type for function %q+#D", decl); - else if (TREE_CODE (decl) == IDENTIFIER_NODE) + else if (identifier_p (decl)) /* Here we do not have location information. */ error ("invalid abstract type %qT for %qE", type, decl); 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 +390,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 +416,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 @@ -732,7 +791,7 @@ store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags) will perform the dynamic initialization. */ if (value != error_mark_node && (TREE_SIDE_EFFECTS (value) - || ! initializer_constant_valid_p (value, TREE_TYPE (value)))) + || ! reduced_constant_expression_p (value))) { if (TREE_CODE (type) == ARRAY_TYPE && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type))) @@ -1181,7 +1240,7 @@ process_init_constructor_record (tree type, tree init, latter case can happen in templates where lookup has to be deferred. */ gcc_assert (TREE_CODE (ce->index) == FIELD_DECL - || TREE_CODE (ce->index) == IDENTIFIER_NODE); + || identifier_p (ce->index)); if (ce->index != field && ce->index != DECL_NAME (field)) { @@ -1307,7 +1366,7 @@ process_init_constructor_union (tree type, tree init, { if (TREE_CODE (ce->index) == FIELD_DECL) ; - else if (TREE_CODE (ce->index) == IDENTIFIER_NODE) + else if (identifier_p (ce->index)) { /* This can happen within a cast, see g++.dg/opt/cse2.C. */ tree name = ce->index; @@ -1729,7 +1788,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/df-core.c b/gcc/df-core.c index e3a5524c3d4..d392cd6867e 100644 --- a/gcc/df-core.c +++ b/gcc/df-core.c @@ -727,9 +727,7 @@ rest_of_handle_df_initialize (void) df->n_blocks_inverted = inverted_post_order_compute (df->postorder_inverted); gcc_assert (df->n_blocks == df->n_blocks_inverted); - df->hard_regs_live_count = XNEWVEC (unsigned int, FIRST_PSEUDO_REGISTER); - memset (df->hard_regs_live_count, 0, - sizeof (unsigned int) * FIRST_PSEUDO_REGISTER); + df->hard_regs_live_count = XCNEWVEC (unsigned int, FIRST_PSEUDO_REGISTER); df_hard_reg_init (); /* After reload, some ports add certain bits to regs_ever_live so @@ -1074,8 +1072,7 @@ df_worklist_dataflow (struct dataflow *dataflow, gcc_assert (dir != DF_NONE); /* BBINDEX_TO_POSTORDER maps the bb->index to the reverse postorder. */ - bbindex_to_postorder = - (unsigned int *)xmalloc (last_basic_block * sizeof (unsigned int)); + bbindex_to_postorder = XNEWVEC (unsigned int, last_basic_block); /* Initialize the array to an out-of-bound value. */ for (i = 0; i < last_basic_block; i++) diff --git a/gcc/df-scan.c b/gcc/df-scan.c index 931fa2c7e48..fdfa93190ce 100644 --- a/gcc/df-scan.c +++ b/gcc/df-scan.c @@ -142,6 +142,8 @@ static void df_install_ref (df_ref, struct df_reg_info *, static int df_ref_compare (const void *, const void *); static int df_mw_compare (const void *, const void *); +static void df_insn_info_delete (unsigned int); + /* Indexed by hardware reg number, is true if that register is ever used in the current function. @@ -277,8 +279,7 @@ df_scan_free_bb_info (basic_block bb, void *vbb_info) FOR_BB_INSNS (bb, insn) { if (INSN_P (insn)) - /* Record defs within INSN. */ - df_insn_delete (bb, INSN_UID (insn)); + df_insn_info_delete (INSN_UID (insn)); } if (bb_index < df_scan->block_info_size) @@ -1087,44 +1088,15 @@ df_mw_hardreg_chain_delete (struct df_mw_hardreg **hardregs) } -/* Delete all of the refs information from INSN. BB must be passed in - except when called from df_process_deferred_rescans to mark the block - as dirty. */ +/* Delete all of the refs information from the insn with UID. + Internal helper for df_insn_delete, df_insn_rescan, and other + df-scan routines that don't have to work in deferred mode + and do not have to mark basic blocks for re-processing. */ -void -df_insn_delete (basic_block bb, unsigned int uid) +static void +df_insn_info_delete (unsigned int uid) { - struct df_insn_info *insn_info = NULL; - if (!df) - return; - - df_grow_bb_info (df_scan); - df_grow_reg_info (); - - /* The block must be marked as dirty now, rather than later as in - df_insn_rescan and df_notes_rescan because it may not be there at - rescanning time and the mark would blow up. */ - if (bb) - df_set_bb_dirty (bb); - - insn_info = DF_INSN_UID_SAFE_GET (uid); - - /* The client has deferred rescanning. */ - if (df->changeable_flags & DF_DEFER_INSN_RESCAN) - { - if (insn_info) - { - bitmap_clear_bit (&df->insns_to_rescan, uid); - bitmap_clear_bit (&df->insns_to_notes_rescan, uid); - bitmap_set_bit (&df->insns_to_delete, uid); - } - if (dump_file) - fprintf (dump_file, "deferring deletion of insn with uid = %d.\n", uid); - return; - } - - if (dump_file) - fprintf (dump_file, "deleting insn with uid = %d.\n", uid); + struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid); bitmap_clear_bit (&df->insns_to_delete, uid); bitmap_clear_bit (&df->insns_to_rescan, uid); @@ -1160,6 +1132,67 @@ df_insn_delete (basic_block bb, unsigned int uid) } } +/* Delete all of the refs information from INSN, either right now + or marked for later in deferred mode. */ + +void +df_insn_delete (rtx insn) +{ + unsigned int uid; + basic_block bb; + + gcc_checking_assert (INSN_P (insn)); + + if (!df) + return; + + uid = INSN_UID (insn); + bb = BLOCK_FOR_INSN (insn); + + /* ??? bb can be NULL after pass_free_cfg. At that point, DF should + not exist anymore (as mentioned in df-core.c: "The only requirement + [for DF] is that there be a correct control flow graph." Clearly + that isn't the case after pass_free_cfg. But DF is freed much later + because some back-ends want to use DF info even though the CFG is + already gone. It's not clear to me whether that is safe, actually. + In any case, we expect BB to be non-NULL at least up to register + allocation, so disallow a non-NULL BB up to there. Not perfect + but better than nothing... */ + + gcc_checking_assert (bb != NULL || reload_completed); + + df_grow_bb_info (df_scan); + df_grow_reg_info (); + + /* The block must be marked as dirty now, rather than later as in + df_insn_rescan and df_notes_rescan because it may not be there at + rescanning time and the mark would blow up. + DEBUG_INSNs do not make a block's data flow solution dirty (at + worst the LUIDs are no longer contiguous). */ + if (bb != NULL && NONDEBUG_INSN_P (insn)) + df_set_bb_dirty (bb); + + /* The client has deferred rescanning. */ + if (df->changeable_flags & DF_DEFER_INSN_RESCAN) + { + struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid); + if (insn_info) + { + bitmap_clear_bit (&df->insns_to_rescan, uid); + bitmap_clear_bit (&df->insns_to_notes_rescan, uid); + bitmap_set_bit (&df->insns_to_delete, uid); + } + if (dump_file) + fprintf (dump_file, "deferring deletion of insn with uid = %d.\n", uid); + return; + } + + if (dump_file) + fprintf (dump_file, "deleting insn with uid = %d.\n", uid); + + df_insn_info_delete (uid); +} + /* Free all of the refs and the mw_hardregs in COLLECTION_REC. */ @@ -1262,7 +1295,7 @@ df_insn_rescan (rtx insn) /* There's change - we need to delete the existing info. Since the insn isn't moved, we can salvage its LUID. */ luid = DF_INSN_LUID (insn); - df_insn_delete (NULL, uid); + df_insn_info_delete (uid); df_insn_create_insn_record (insn); DF_INSN_LUID (insn) = luid; } @@ -1345,7 +1378,7 @@ df_insn_rescan_debug_internal (rtx insn) /* Rescan all of the insns in the function. Note that the artificial - uses and defs are not touched. This function will destroy def-se + uses and defs are not touched. This function will destroy def-use or use-def chains. */ void @@ -1377,7 +1410,7 @@ df_insn_rescan_all (void) { struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid); if (insn_info) - df_insn_delete (NULL, uid); + df_insn_info_delete (uid); } bitmap_clear (&tmp); @@ -1434,7 +1467,7 @@ df_process_deferred_rescans (void) { struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid); if (insn_info) - df_insn_delete (NULL, uid); + df_insn_info_delete (uid); } bitmap_copy (&tmp, &df->insns_to_rescan); @@ -996,7 +996,7 @@ extern df_ref df_ref_create (rtx, rtx *, rtx,basic_block, extern void df_uses_create (rtx *, rtx, int); extern void df_ref_remove (df_ref); extern struct df_insn_info * df_insn_create_insn_record (rtx); -extern void df_insn_delete (basic_block, unsigned int); +extern void df_insn_delete (rtx); extern void df_bb_refs_record (int, bool); extern bool df_insn_rescan (rtx); extern bool df_insn_rescan_debug_internal (rtx); diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c index a365c608a91..87eb8dc40ab 100644 --- a/gcc/diagnostic.c +++ b/gcc/diagnostic.c @@ -729,7 +729,10 @@ diagnostic_report_diagnostic (diagnostic_context *context, diagnostic->message.format_spec, diagnostic->message.args_ptr); } - ++diagnostic_kind_count (context, diagnostic->kind); + if (diagnostic->kind == DK_ERROR && orig_diag_kind == DK_WARNING) + ++diagnostic_kind_count (context, DK_WERROR); + else + ++diagnostic_kind_count (context, diagnostic->kind); saved_format_spec = diagnostic->message.format_spec; if (context->show_option_requested) diff --git a/gcc/diagnostic.def b/gcc/diagnostic.def index 53179e445cd..9566491ca2a 100644 --- a/gcc/diagnostic.def +++ b/gcc/diagnostic.def @@ -42,4 +42,6 @@ DEFINE_DIAGNOSTIC_KIND (DK_DEBUG, "debug: ") prefix does not matter. */ DEFINE_DIAGNOSTIC_KIND (DK_PEDWARN, "pedwarn: ") DEFINE_DIAGNOSTIC_KIND (DK_PERMERROR, "permerror: ") - +/* This one is just for counting DK_WARNING promoted to DK_ERROR + due to -Werror and -Werror=warning. */ +DEFINE_DIAGNOSTIC_KIND (DK_WERROR, "error: ") diff --git a/gcc/diagnostic.h b/gcc/diagnostic.h index f0fae96275b..3b500964c7d 100644 --- a/gcc/diagnostic.h +++ b/gcc/diagnostic.h @@ -240,6 +240,8 @@ extern diagnostic_context *global_dc; #define errorcount diagnostic_kind_count (global_dc, DK_ERROR) /* Similarly, but for warnings. */ #define warningcount diagnostic_kind_count (global_dc, DK_WARNING) +/* Similarly, but for warnings promoted to errors. */ +#define werrorcount diagnostic_kind_count (global_dc, DK_WERROR) /* Similarly, but for sorrys. */ #define sorrycount diagnostic_kind_count (global_dc, DK_SORRY) diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index ca655153067..80628a3cb90 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -79,6 +79,7 @@ extensions, accepted by GCC in C90 mode and in C++. * Offsetof:: Special syntax for implementing @code{offsetof}. * __sync Builtins:: Legacy built-in functions for atomic memory access. * __atomic Builtins:: Atomic built-in functions with memory model. +* x86 specific memory model extensions for transactional memory:: x86 memory models. * Object Size Checking:: Built-in functions for limited buffer overflow checking. * Other Builtins:: Other built-in functions. @@ -3054,6 +3055,25 @@ not that within individual functions. Mixed MIPS16 and non-MIPS16 code may interact badly with some GCC extensions such as @code{__builtin_apply} (@pxref{Constructing Calls}). +@item micromips/nomicromips +@cindex @code{micromips} attribute +@cindex @code{nomicromips} attribute + +On MIPS targets, you can use the @code{micromips} and @code{nomicromips} +function attributes to locally select or turn off microMIPS code generation. +A function with the @code{micromips} attribute is emitted as microMIPS code, +while microMIPS code generation is disabled for functions with the +@code{nomicromips} attribute. These attributes override the +@option{-mmicromips} and @option{-mno-micromips} options on the command line +(@pxref{MIPS Options}). + +When compiling files containing mixed microMIPS and non-microMIPS code, the +preprocessor symbol @code{__mips_micromips} reflects the setting on the +command line, +not that within individual functions. Mixed microMIPS and non-microMIPS code +may interact badly with some GCC extensions such as @code{__builtin_apply} +(@pxref{Constructing Calls}). + @item model (@var{model-name}) @cindex function addressability on the M32R/D @cindex variable addressability on the IA-64 @@ -3156,6 +3176,13 @@ is an NMI handler. The compiler generates function entry and exit sequences suitable for use in an NMI handler when this attribute is present. +@item nocompression +@cindex @code{nocompression} attribute +On MIPS targets, you can use the @code{nocompression} function attribute +to locally turn off MIPS16 and microMIPS code generation. This attribute +overrides the @option{-mips16} and @option{-mmicromips} options on the +command line (@pxref{MIPS Options}). + @item no_instrument_function @cindex @code{no_instrument_function} function attribute @opindex finstrument-functions @@ -7474,6 +7501,37 @@ alignment. A value of 0 indicates typical alignment should be used. The compiler may also ignore this parameter. @end deftypefn +@node x86 specific memory model extensions for transactional memory +@section x86 specific memory model extensions for transactional memory + +The i386 architecture supports additional memory ordering flags +to mark lock critical sections for hardware lock elision. +These must be specified in addition to an existing memory model to +atomic intrinsics. + +@table @code +@item __ATOMIC_HLE_ACQUIRE +Start lock elision on a lock variable. +Memory model must be @code{__ATOMIC_ACQUIRE} or stronger. +@item __ATOMIC_HLE_RELEASE +End lock elision on a lock variable. +Memory model must be @code{__ATOMIC_RELEASE} or stronger. +@end table + +When a lock acquire fails it's required for good performance to abort +the transaction quickly. This can be done with a @code{_mm_pause} + +@smallexample +#include <immintrin.h> // For _mm_pause + +/* Acquire lock with lock elision */ +while (__atomic_exchange_n(&lockvar, 1, __ATOMIC_ACQUIRE|__ATOMIC_HLE_ACQUIRE)) + _mm_pause(); /* Abort failed transaction */ +... +/* Free lock with lock elision */ +__atomic_clear(&lockvar, __ATOMIC_RELEASE|__ATOMIC_HLE_RELEASE); +@end smallexample + @node Object Size Checking @section Object Size Checking Built-in Functions @findex __builtin_object_size @@ -8745,6 +8803,7 @@ instructions, but allow the compiler to schedule those calls. * Blackfin Built-in Functions:: * FR-V Built-in Functions:: * X86 Built-in Functions:: +* X86 transactional memory intrinsics:: * MIPS DSP Built-in Functions:: * MIPS Paired-Single Support:: * MIPS Loongson Built-in Functions:: @@ -10925,6 +10984,88 @@ v2sf __builtin_ia32_pswapdsf (v2sf) v2si __builtin_ia32_pswapdsi (v2si) @end smallexample +The following built-in functions are available when @option{-mrtm} is used +They are used for restricted transactional memory. These are the internal +low level functions. Normally the functions in +@ref{X86 transactional memory intrinsics} should be used instead. + +@smallexample +int __builtin_ia32_xbegin () +void __builtin_ia32_xend () +void __builtin_ia32_xabort (status) +int __builtin_ia32_xtest () +@end smallexample + +@node X86 transactional memory intrinsics +@subsection X86 transaction memory intrinsics + +Hardware transactional memory intrinsics for i386. These allow to use +memory transactions with RTM (Restricted Transactional Memory). +For using HLE (Hardware Lock Elision) see @ref{x86 specific memory model extensions for transactional memory} instead. +This support is enabled with the @option{-mrtm} option. + +A memory transaction commits all changes to memory in an atomic way, +as visible to other threads. If the transaction fails it is rolled back +and all side effects discarded. + +Generally there is no guarantee that a memory transaction ever suceeds +and suitable fallback code always needs to be supplied. + +@deftypefn {RTM Function} {unsigned} _xbegin () +Start a RTM (Restricted Transactional Memory) transaction. +Returns _XBEGIN_STARTED when the transaction +started successfully (note this is not 0, so the constant has to be +explicitely tested). When the transaction aborts all side effects +are undone and an abort code is returned. There is no guarantee +any transaction ever succeeds, so there always needs to be a valid +tested fallback path. +@end deftypefn + +@smallexample +#include <immintrin.h> + +if ((status = _xbegin ()) == _XBEGIN_STARTED) @{ + ... transaction code... + _xend (); +@} else @{ + ... non transactional fallback path... +@} +@end smallexample + +Valid abort status bits (when the value is not @code{_XBEGIN_STARTED}) are: + +@table @code +@item _XABORT_EXPLICIT +Transaction explicitely aborted with @code{_xabort}. The parameter passed +to @code{_xabort} is available with @code{_XABORT_CODE(status)} +@item _XABORT_RETRY +Transaction retry is possible. +@item _XABORT_CONFLICT +Transaction abort due to a memory conflict with another thread +@item _XABORT_CAPACITY +Transaction abort due to the transaction using too much memory +@item _XABORT_DEBUG +Transaction abort due to a debug trap +@item _XABORT_NESTED +Transaction abort in a inner nested transaction +@end table + +@deftypefn {RTM Function} {void} _xend () +Commit the current transaction. When no transaction is active this will +fault. All memory side effects of the transactions will become visible +to other threads in an atomic matter. +@end deftypefn + +@deftypefn {RTM Function} {int} _xtest () +Return a value not zero when a transaction is currently active, otherwise 0. +@end deftypefn + +@deftypefn {RTM Function} {void} _xabort (status) +Abort the current transaction. When no transaction is active this is a no-op. +status must be a 8bit constant, that is included in the status code returned +by @code{_xbegin} +@end deftypefn + @node MIPS DSP Built-in Functions @subsection MIPS DSP Built-in Functions diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index d81c78d2ab5..9b8b36a52e3 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -232,7 +232,8 @@ Objective-C and Objective-C++ Dialects}. @xref{Warning Options,,Options to Request or Suppress Warnings}. @gccoptlist{-fsyntax-only -fmax-errors=@var{n} -Wpedantic @gol -pedantic-errors @gol --w -Wextra -Wall -Waddress -Waggregate-return -Warray-bounds @gol +-w -Wextra -Wall -Waddress -Waggregate-return @gol +-Waggressive-loop-optimizations -Warray-bounds @gol -Wno-attributes -Wno-builtin-macro-redefined @gol -Wc++-compat -Wc++11-compat -Wcast-align -Wcast-qual @gol -Wchar-subscripts -Wclobbered -Wcomment @gol @@ -509,12 +510,13 @@ Objective-C and Objective-C++ Dialects}. -mtp=@var{name} -mtls-dialect=@var{dialect} @gol -mword-relocations @gol -mfix-cortex-m3-ldrd @gol --munaligned-access} +-munaligned-access @gol +-mneon-for-64bits} @emph{AVR Options} @gccoptlist{-mmcu=@var{mcu} -maccumulate-args -mbranch-cost=@var{cost} @gol -mcall-prologues -mint8 -mno-interrupts -mrelax @gol --mstrict-X -mtiny-stack} +-mstrict-X -mtiny-stack -Waddr-space-convert} @emph{Blackfin Options} @gccoptlist{-mcpu=@var{cpu}@r{[}-@var{sirevision}@r{]} @gol @@ -740,6 +742,7 @@ Objective-C and Objective-C++ Dialects}. -mips1 -mips2 -mips3 -mips4 -mips32 -mips32r2 @gol -mips64 -mips64r2 @gol -mips16 -mno-mips16 -mflip-mips16 @gol +-minterlink-compressed -mno-interlink-compressed @gol -minterlink-mips16 -mno-interlink-mips16 @gol -mabi=@var{abi} -mabicalls -mno-abicalls @gol -mshared -mno-shared -mplt -mno-plt -mxgot -mno-xgot @gol @@ -747,6 +750,7 @@ Objective-C and Objective-C++ Dialects}. -mno-float -msingle-float -mdouble-float @gol -mdsp -mno-dsp -mdspr2 -mno-dspr2 @gol -mmcu -mmno-mcu @gol +-mmicromips -mno-micromips @gol -mfpu=@var{fpu-type} @gol -msmartmips -mno-smartmips @gol -mpaired-single -mno-paired-single -mdmx -mno-mdmx @gol @@ -4423,6 +4427,12 @@ Warn if any functions that return structures or unions are defined or called. (In languages where you can return an array, this also elicits a warning.) +@item -Wno-aggressive-loop-optimizations +@opindex Wno-aggressive-loop-optimizations +@opindex Waggressive-loop-optimizations +Warn if in a loop with constant number of iterations the compiler detects +undefined behavior in some statement during one or more of the iterations. + @item -Wno-attributes @opindex Wno-attributes @opindex Wattributes @@ -11521,6 +11531,11 @@ setting of this option. If unaligned access is enabled then the preprocessor symbol @code{__ARM_FEATURE_UNALIGNED} will also be defined. +@item -mneon-for-64bits +@opindex mneon-for-64bits +Enables using Neon to handle scalar 64-bits operations. This is +disabled by default since the cost of moving data from core registers +to Neon is high. @end table @node AVR Options @@ -11632,6 +11647,11 @@ sbiw r26, const ; X -= const @item -mtiny-stack @opindex mtiny-stack Only change the lower 8@tie{}bits of the stack pointer. + +@item -Waddr-space-convert +@opindex Waddr-space-convert +Warn about conversions between address spaces in the case where the +resulting address space is not contained in the incoming address space. @end table @subsubsection @code{EIND} and Devices with more than 128 Ki Bytes of Flash @@ -15890,6 +15910,7 @@ The processor names are: @samp{1004kc}, @samp{1004kf2_1}, @samp{1004kf1_1}, @samp{loongson2e}, @samp{loongson2f}, @samp{loongson3a}, @samp{m4k}, +@samp{m14k}, @samp{m14ke}, @samp{m14kec}, @samp{octeon}, @samp{octeon+}, @samp{octeon2}, @samp{orion}, @samp{r2000}, @samp{r3000}, @samp{r3900}, @samp{r4000}, @samp{r4400}, @@ -16003,17 +16024,25 @@ Generate MIPS16 code on alternating functions. This option is provided for regression testing of mixed MIPS16/non-MIPS16 code generation, and is not intended for ordinary use in compiling user code. +@item -minterlink-compressed +@item -mno-interlink-compressed +@opindex minterlink-compressed +@opindex mno-interlink-compressed +Require (do not require) that code using the standard (uncompressed) MIPS ISA +be link-compatible with MIPS16 and microMIPS code, and vice versa. + +For example, code using the standard ISA encoding cannot jump directly +to MIPS16 or microMIPS code; it must either use a call or an indirect jump. +@option{-minterlink-compressed} therefore disables direct jumps unless GCC +knows that the target of the jump is not compressed. + @item -minterlink-mips16 @itemx -mno-interlink-mips16 @opindex minterlink-mips16 @opindex mno-interlink-mips16 -Require (do not require) that non-MIPS16 code be link-compatible with -MIPS16 code. - -For example, non-MIPS16 code cannot jump directly to MIPS16 code; -it must either use a call or an indirect jump. @option{-minterlink-mips16} -therefore disables direct jumps unless GCC knows that the target of the -jump is not MIPS16. +Aliases of @option{-minterlink-compressed} and +@option{-mno-interlink-compressed}. These options predate the microMIPS ASE +and are retained for backwards compatiblity. @item -mabi=32 @itemx -mabi=o64 @@ -16228,6 +16257,16 @@ hardware floating-point support to be enabled. Use (do not use) the MIPS-3D ASE@. @xref{MIPS-3D Built-in Functions}. The option @option{-mips3d} implies @option{-mpaired-single}. +@item -mmicromips +@itemx -mno-micromips +@opindex mmicromips +@opindex mno-mmicromips +Generate (do not generate) microMIPS code. + +MicroMIPS code generation can also be controlled on a per-function basis +by means of @code{micromips} and @code{nomicromips} attributes. +@xref{Function Attributes}, for more information. + @item -mmt @itemx -mno-mt @opindex mmt diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi index 63ec92f6b25..6729eb691fd 100644 --- a/gcc/doc/md.texi +++ b/gcc/doc/md.texi @@ -2075,9 +2075,24 @@ VSX vector register to hold vector double data @item wf VSX vector register to hold vector float data +@item wg +If @option{-mmfpgpr} was used, a floating point register + +@item wl +If the LFIWAX instruction is enabled, a floating point register + @item ws VSX vector register to hold scalar float data +@item wt +VSX vector register to hold 128 bit integer + +@item wx +If the STFIWX instruction is enabled, a floating point register + +@item wz +If the LFIWZX instruction is enabled, a floating point register + @item wa Any VSX register @@ -2916,6 +2931,19 @@ Floating-point zero. @item R An address that can be used in a non-macro load or store. + +@item ZC +When compiling microMIPS code, this constraint matches a memory operand +whose address is formed from a base register and a 12-bit offset. These +operands can be used for microMIPS instructions such as @code{ll} and +@code{sc}. When not compiling for microMIPS code, @code{ZC} is +equivalent to @code{R}. + +@item ZD +When compiling microMIPS code, this constraint matches an address operand +that is formed from a base register and a 12-bit offset. These operands +can be used for microMIPS instructions such as @code{prefetch}. When +not compiling for microMIPS code, @code{ZD} is equivalent to @code{p}. @end table @item Motorola 680x0---@file{config/m68k/constraints.md} 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 01d5f7108a0..12d8578cb9e 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -5012,13 +5012,13 @@ add_var_loc_to_decl (tree decl, rtx loc_note, const char *label) struct var_loc_node *loc = NULL; HOST_WIDE_INT bitsize = -1, bitpos = -1; - if (DECL_DEBUG_EXPR_IS_FROM (decl)) + if (TREE_CODE (decl) == VAR_DECL + && DECL_HAS_DEBUG_EXPR_P (decl)) { tree realdecl = DECL_DEBUG_EXPR (decl); - if (realdecl - && (handled_component_p (realdecl) - || (TREE_CODE (realdecl) == MEM_REF - && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))) + if (handled_component_p (realdecl) + || (TREE_CODE (realdecl) == MEM_REF + && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR)) { HOST_WIDE_INT maxsize; tree innerdecl; @@ -5051,7 +5051,7 @@ add_var_loc_to_decl (tree decl, rtx loc_note, const char *label) if (temp->last && temp->first == temp->last && TREE_CODE (decl) == PARM_DECL - && GET_CODE (temp->first->loc) == NOTE + && NOTE_P (temp->first->loc) && NOTE_VAR_LOCATION_DECL (temp->first->loc) == decl && DECL_INCOMING_RTL (decl) && NOTE_VAR_LOCATION_LOC (temp->first->loc) @@ -7850,6 +7850,8 @@ size_of_aranges (void) FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde) { + if (DECL_IGNORED_P (fde->decl)) + continue; if (!fde->in_std_section) size += 2 * DWARF2_ADDR_SIZE; if (fde->dw_fde_second_begin && !fde->second_in_std_section) @@ -10240,6 +10242,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; @@ -10259,9 +10262,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); @@ -10276,12 +10284,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); } } } @@ -13467,7 +13477,7 @@ dw_loc_list (var_loc_list *loc_list, tree decl, int want_address) *listp = new_loc_list (descr, node->label, endname, secname); if (TREE_CODE (decl) == PARM_DECL && node == loc_list->first - && GET_CODE (node->loc) == NOTE + && NOTE_P (node->loc) && strcmp (node->label, endname) == 0) (*listp)->force = true; listp = &(*listp)->dw_loc_next; @@ -15521,6 +15531,7 @@ tree_add_const_value_attribute (dw_die_ref die, tree t) add_AT_vec (die, DW_AT_const_value, size, 1, array); return true; } + ggc_free (array); } } return false; @@ -20693,7 +20704,7 @@ dwarf2out_var_location (rtx loc_note) next_note = NEXT_INSN (loc_note); if (! next_note || INSN_DELETED_P (next_note) - || GET_CODE (next_note) != NOTE + || ! NOTE_P (next_note) || (NOTE_KIND (next_note) != NOTE_INSN_VAR_LOCATION && NOTE_KIND (next_note) != NOTE_INSN_CALL_ARG_LOCATION)) next_note = NULL_RTX; @@ -22497,6 +22508,10 @@ resolve_one_addr (rtx *addr, void *data ATTRIBUTE_UNUSED) if (!rtl || !MEM_P (rtl)) return 1; rtl = XEXP (rtl, 0); + if (GET_CODE (rtl) == SYMBOL_REF + && SYMBOL_REF_DECL (rtl) + && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl))) + return 1; vec_safe_push (used_rtx_array, rtl); *addr = rtl; return 0; @@ -22521,6 +22536,103 @@ resolve_one_addr (rtx *addr, void *data ATTRIBUTE_UNUSED) return 0; } +/* For STRING_CST, return SYMBOL_REF of its constant pool entry, + if possible, and create DW_TAG_dwarf_procedure that can be referenced + from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */ + +static rtx +string_cst_pool_decl (tree t) +{ + rtx rtl = output_constant_def (t, 1); + unsigned char *array; + dw_loc_descr_ref l; + tree decl; + size_t len; + dw_die_ref ref; + + if (!rtl || !MEM_P (rtl)) + return NULL_RTX; + rtl = XEXP (rtl, 0); + if (GET_CODE (rtl) != SYMBOL_REF + || SYMBOL_REF_DECL (rtl) == NULL_TREE) + return NULL_RTX; + + decl = SYMBOL_REF_DECL (rtl); + if (!lookup_decl_die (decl)) + { + len = TREE_STRING_LENGTH (t); + vec_safe_push (used_rtx_array, rtl); + ref = new_die (DW_TAG_dwarf_procedure, comp_unit_die (), decl); + array = (unsigned char *) ggc_alloc_atomic (len); + memcpy (array, TREE_STRING_POINTER (t), len); + l = new_loc_descr (DW_OP_implicit_value, len, 0); + l->dw_loc_oprnd2.val_class = dw_val_class_vec; + l->dw_loc_oprnd2.v.val_vec.length = len; + l->dw_loc_oprnd2.v.val_vec.elt_size = 1; + l->dw_loc_oprnd2.v.val_vec.array = array; + add_AT_loc (ref, DW_AT_location, l); + equate_decl_number_to_die (decl, ref); + } + return rtl; +} + +/* Helper function of resolve_addr_in_expr. LOC is + a DW_OP_addr followed by DW_OP_stack_value, either at the start + of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be + resolved. Replace it (both DW_OP_addr and DW_OP_stack_value) + with DW_OP_GNU_implicit_pointer if possible + and return true, if unsuccesful, return false. */ + +static bool +optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc) +{ + rtx rtl = loc->dw_loc_oprnd1.v.val_addr; + HOST_WIDE_INT offset = 0; + dw_die_ref ref = NULL; + tree decl; + + if (GET_CODE (rtl) == CONST + && GET_CODE (XEXP (rtl, 0)) == PLUS + && CONST_INT_P (XEXP (XEXP (rtl, 0), 1))) + { + offset = INTVAL (XEXP (XEXP (rtl, 0), 1)); + rtl = XEXP (XEXP (rtl, 0), 0); + } + if (GET_CODE (rtl) == CONST_STRING) + { + size_t len = strlen (XSTR (rtl, 0)) + 1; + tree t = build_string (len, XSTR (rtl, 0)); + tree tlen = size_int (len - 1); + + TREE_TYPE (t) + = build_array_type (char_type_node, build_index_type (tlen)); + rtl = string_cst_pool_decl (t); + if (!rtl) + return false; + } + if (GET_CODE (rtl) == SYMBOL_REF && SYMBOL_REF_DECL (rtl)) + { + decl = SYMBOL_REF_DECL (rtl); + if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) + { + ref = lookup_decl_die (decl); + if (ref && (get_AT (ref, DW_AT_location) + || get_AT (ref, DW_AT_const_value))) + { + loc->dw_loc_opc = DW_OP_GNU_implicit_pointer; + loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref; + loc->dw_loc_oprnd1.val_entry = NULL; + loc->dw_loc_oprnd1.v.val_die_ref.die = ref; + loc->dw_loc_oprnd1.v.val_die_ref.external = 0; + loc->dw_loc_next = loc->dw_loc_next->dw_loc_next; + loc->dw_loc_oprnd2.v.val_int = offset; + return true; + } + } + } + return false; +} + /* Helper function for resolve_addr, handle one location expression, return false if at least one CONST_STRING or SYMBOL_REF in the location list couldn't be resolved. */ @@ -22529,23 +22641,31 @@ static bool resolve_addr_in_expr (dw_loc_descr_ref loc) { dw_loc_descr_ref keep = NULL; - for (; loc; loc = loc->dw_loc_next) + for (dw_loc_descr_ref prev = NULL; loc; prev = loc, loc = loc->dw_loc_next) switch (loc->dw_loc_opc) { case DW_OP_addr: if (resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr, NULL)) - return false; + { + if ((prev == NULL + || prev->dw_loc_opc == DW_OP_piece + || prev->dw_loc_opc == DW_OP_bit_piece) + && loc->dw_loc_next + && loc->dw_loc_next->dw_loc_opc == DW_OP_stack_value + && !dwarf_strict + && optimize_one_addr_into_implicit_ptr (loc)) + break; + return false; + } break; case DW_OP_GNU_addr_index: case DW_OP_GNU_const_index: - { - if ((loc->dw_loc_opc == DW_OP_GNU_addr_index - || (loc->dw_loc_opc == DW_OP_GNU_const_index && loc->dtprel)) - && resolve_one_addr (&loc->dw_loc_oprnd1.val_entry->addr.rtl, - NULL)) - return false; - } - break; + if ((loc->dw_loc_opc == DW_OP_GNU_addr_index + || (loc->dw_loc_opc == DW_OP_GNU_const_index && loc->dtprel)) + && resolve_one_addr (&loc->dw_loc_oprnd1.val_entry->addr.rtl, + NULL)) + return false; + break; case DW_OP_const4u: case DW_OP_const8u: if (loc->dtprel @@ -22640,6 +22760,80 @@ resolve_addr_in_expr (dw_loc_descr_ref loc) return true; } +/* Helper function of resolve_addr. DIE had DW_AT_location of + DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand + and DW_OP_addr couldn't be resolved. resolve_addr has already + removed the DW_AT_location attribute. This function attempts to + add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer + to it or DW_AT_const_value attribute, if possible. */ + +static void +optimize_location_into_implicit_ptr (dw_die_ref die, tree decl) +{ + if (TREE_CODE (decl) != VAR_DECL + || lookup_decl_die (decl) != die + || DECL_EXTERNAL (decl) + || !TREE_STATIC (decl) + || DECL_INITIAL (decl) == NULL_TREE + || DECL_P (DECL_INITIAL (decl)) + || get_AT (die, DW_AT_const_value)) + return; + + tree init = DECL_INITIAL (decl); + HOST_WIDE_INT offset = 0; + /* For variables that have been optimized away and thus + don't have a memory location, see if we can emit + DW_AT_const_value instead. */ + if (tree_add_const_value_attribute (die, init)) + return; + if (dwarf_strict) + return; + /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR, + and ADDR_EXPR refers to a decl that has DW_AT_location or + DW_AT_const_value (but isn't addressable, otherwise + resolving the original DW_OP_addr wouldn't fail), see if + we can add DW_OP_GNU_implicit_pointer. */ + STRIP_NOPS (init); + if (TREE_CODE (init) == POINTER_PLUS_EXPR + && host_integerp (TREE_OPERAND (init, 1), 0)) + { + offset = tree_low_cst (TREE_OPERAND (init, 1), 0); + init = TREE_OPERAND (init, 0); + STRIP_NOPS (init); + } + if (TREE_CODE (init) != ADDR_EXPR) + return; + if ((TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST + && !TREE_ASM_WRITTEN (TREE_OPERAND (init, 0))) + || (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL + && !DECL_EXTERNAL (TREE_OPERAND (init, 0)) + && TREE_OPERAND (init, 0) != decl)) + { + dw_die_ref ref; + dw_loc_descr_ref l; + + if (TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST) + { + rtx rtl = string_cst_pool_decl (TREE_OPERAND (init, 0)); + if (!rtl) + return; + decl = SYMBOL_REF_DECL (rtl); + } + else + decl = TREE_OPERAND (init, 0); + ref = lookup_decl_die (decl); + if (ref == NULL + || (!get_AT (ref, DW_AT_location) + && !get_AT (ref, DW_AT_const_value))) + return; + l = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset); + l->dw_loc_oprnd1.val_class = dw_val_class_die_ref; + l->dw_loc_oprnd1.v.val_die_ref.die = ref; + l->dw_loc_oprnd1.v.val_die_ref.external = 0; + add_AT_loc (die, DW_AT_location, l); + } +} + /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to an address in .rodata section if the string literal is emitted there, or remove the containing location list or replace DW_AT_const_value @@ -22726,8 +22920,21 @@ resolve_addr (dw_die_ref die) || l->dw_loc_next != NULL) && !resolve_addr_in_expr (l)) { - if (dwarf_split_debug_info) - remove_loc_list_addr_table_entries (l); + if (dwarf_split_debug_info) + remove_loc_list_addr_table_entries (l); + if (l != NULL + && l->dw_loc_next == NULL + && l->dw_loc_opc == DW_OP_addr + && GET_CODE (l->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF + && SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr) + && a->dw_attr == DW_AT_location) + { + tree decl = SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr); + remove_AT (die, a->dw_attr); + ix--; + optimize_location_into_implicit_ptr (die, decl); + break; + } remove_AT (die, a->dw_attr); ix--; } diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c index 2c70fb1841d..31c1e638d7c 100644 --- a/gcc/emit-rtl.c +++ b/gcc/emit-rtl.c @@ -2580,10 +2580,14 @@ verify_rtx_sharing (rtx orig, rtx insn) case RETURN: case SIMPLE_RETURN: case SCRATCH: - return; /* SCRATCH must be shared because they represent distinct values. */ + return; case CLOBBER: - if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER) + /* Share clobbers of hard registers (like cc0), but do not share pseudo reg + clobbers or clobbers of hard registers that originated as pseudos. + This is needed to allow safe register renaming. */ + if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER + && ORIGINAL_REGNO (XEXP (x, 0)) == REGNO (XEXP (x, 0))) return; break; @@ -2797,7 +2801,11 @@ repeat: /* SCRATCH must be shared because they represent distinct values. */ return; case CLOBBER: - if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER) + /* Share clobbers of hard registers (like cc0), but do not share pseudo reg + clobbers or clobbers of hard registers that originated as pseudos. + This is needed to allow safe register renaming. */ + if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER + && ORIGINAL_REGNO (XEXP (x, 0)) == REGNO (XEXP (x, 0))) return; break; @@ -3956,7 +3964,8 @@ add_insn_before (rtx insn, rtx before, basic_block bb) void set_insn_deleted (rtx insn) { - df_insn_delete (BLOCK_FOR_INSN (insn), INSN_UID (insn)); + if (INSN_P (insn) && !JUMP_TABLE_DATA_P (insn)) + df_insn_delete (insn); PUT_CODE (insn, NOTE); NOTE_KIND (insn) = NOTE_INSN_DELETED; } @@ -3971,9 +3980,6 @@ remove_insn (rtx insn) rtx prev = PREV_INSN (insn); basic_block bb; - /* Later in the code, the block will be marked dirty. */ - df_insn_delete (NULL, INSN_UID (insn)); - if (prev) { NEXT_INSN (prev) = next; @@ -4024,11 +4030,15 @@ remove_insn (rtx insn) gcc_assert (stack); } + + /* Invalidate data flow information associated with INSN. */ + if (INSN_P (insn) && !JUMP_TABLE_DATA_P (insn)) + df_insn_delete (insn); + + /* Fix up basic block boundaries, if necessary. */ if (!BARRIER_P (insn) && (bb = BLOCK_FOR_INSN (insn))) { - if (NONDEBUG_INSN_P (insn)) - df_set_bb_dirty (bb); if (BB_HEAD (bb) == insn) { /* Never ever delete the basic block note without deleting whole @@ -5303,7 +5313,11 @@ copy_insn_1 (rtx orig) case SIMPLE_RETURN: return orig; case CLOBBER: - if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER) + /* Share clobbers of hard registers (like cc0), but do not share pseudo reg + clobbers or clobbers of hard registers that originated as pseudos. + This is needed to allow safe register renaming. */ + if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER + && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0))) return orig; break; diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 26cfc0e83e4..905661cf7e6 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)); @@ -4632,7 +4633,7 @@ fold_cond_expr_with_comparison (location_t loc, tree type, if (comp_code == NE_EXPR) return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1)); else if (comp_code == EQ_EXPR) - return build_int_cst (type, 0); + return build_zero_cst (type); } /* Try some transformations of A op B ? A : B. @@ -4666,6 +4667,7 @@ fold_cond_expr_with_comparison (location_t loc, tree type, /* Avoid these transformations if the COND_EXPR may be used as an lvalue in the C++ front-end. PR c++/19199. */ && (in_gimple_form + || VECTOR_TYPE_P (type) || (strcmp (lang_hooks.name, "GNU C++") != 0 && strcmp (lang_hooks.name, "GNU Objective-C++") != 0) || ! maybe_lvalue_p (arg1) @@ -13898,6 +13900,7 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type, return NULL_TREE; case COND_EXPR: + case VEC_COND_EXPR: /* Pedantic ANSI C says that a conditional expression is never an lvalue, so all simple results must be passed through pedantic_non_lvalue. */ if (TREE_CODE (arg0) == INTEGER_CST) @@ -13915,6 +13918,14 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type, return pedantic_non_lvalue_loc (loc, tem); return NULL_TREE; } + else if (TREE_CODE (arg0) == VECTOR_CST) + { + if (integer_all_onesp (arg0)) + return pedantic_omit_one_operand_loc (loc, type, arg1, arg2); + if (integer_zerop (arg0)) + return pedantic_omit_one_operand_loc (loc, type, arg2, arg1); + } + if (operand_equal_p (arg1, op2, 0)) return pedantic_omit_one_operand_loc (loc, type, arg1, arg0); @@ -13950,6 +13961,10 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type, } } + /* ??? Fixup the code below for VEC_COND_EXPR. */ + if (code == VEC_COND_EXPR) + return NULL_TREE; + /* If the second operand is simpler than the third, swap them since that produces better jump optimization results. */ if (truth_value_p (TREE_CODE (arg0)) @@ -14137,16 +14152,6 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type, return NULL_TREE; - case VEC_COND_EXPR: - if (TREE_CODE (arg0) == VECTOR_CST) - { - if (integer_all_onesp (arg0) && !TREE_SIDE_EFFECTS (op2)) - return pedantic_non_lvalue_loc (loc, op1); - if (integer_zerop (arg0) && !TREE_SIDE_EFFECTS (op1)) - return pedantic_non_lvalue_loc (loc, op2); - } - return NULL_TREE; - case CALL_EXPR: /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses of fold_ternary on them. */ @@ -15293,15 +15298,18 @@ tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0, break; case MULT_EXPR: - if (FLOAT_TYPE_P (type)) + if (FLOAT_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type)) { - /* x * x for floating point x is always non-negative. */ - if (operand_equal_p (op0, op1, 0)) - return true; - return (tree_expr_nonnegative_warnv_p (op0, - strict_overflow_p) - && tree_expr_nonnegative_warnv_p (op1, - strict_overflow_p)); + /* x * x is always non-negative for floating point x + or without overflow. */ + if (operand_equal_p (op0, op1, 0) + || (tree_expr_nonnegative_warnv_p (op0, strict_overflow_p) + && tree_expr_nonnegative_warnv_p (op1, strict_overflow_p))) + { + if (TYPE_OVERFLOW_UNDEFINED (type)) + *strict_overflow_p = true; + return true; + } } /* zero_extend(x) * zero_extend(y) is non-negative if x and y are diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 88b514d014b..00bbcd1a201 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,23 @@ +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 + * trans-intrinsic.c (gfc_conv_intrinsic_transfer): Pack arrays + if they are not simply contiguous. + 2013-03-11 Tobias Burnus <burnus@net-b.de> * gfortran.texi (STRUCTURE and RECORD): State more clearly how @@ -212,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-intrinsic.c b/gcc/fortran/trans-intrinsic.c index 83e3acf9eea..a2bb2a78ee7 100644 --- a/gcc/fortran/trans-intrinsic.c +++ b/gcc/fortran/trans-intrinsic.c @@ -5435,9 +5435,8 @@ gfc_conv_intrinsic_transfer (gfc_se * se, gfc_expr * expr) source = gfc_conv_descriptor_data_get (argse.expr); source_type = gfc_get_element_type (TREE_TYPE (argse.expr)); - /* Repack the source if not a full variable array. */ - if (arg->expr->expr_type == EXPR_VARIABLE - && arg->expr->ref->u.ar.type != AR_FULL) + /* Repack the source if not simply contiguous. */ + if (!gfc_is_simply_contiguous (arg->expr, false)) { tmp = gfc_build_addr_expr (NULL_TREE, argse.expr); 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/function.c b/gcc/function.c index e673f21a57d..cd9cb855d40 100644 --- a/gcc/function.c +++ b/gcc/function.c @@ -5093,6 +5093,7 @@ expand_function_end (void) amount. BLKmode results are handled using the group load/store machinery. */ if (TYPE_MODE (TREE_TYPE (decl_result)) != BLKmode + && REG_P (real_decl_rtl) && targetm.calls.return_in_msb (TREE_TYPE (decl_result))) { emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl), @@ -5597,12 +5598,17 @@ prepare_shrink_wrap (basic_block entry_block) static void emit_use_return_register_into_block (basic_block bb) { - rtx seq; + rtx seq, insn; start_sequence (); use_return_register (); seq = get_insns (); end_sequence (); - emit_insn_before (seq, BB_END (bb)); + insn = BB_END (bb); +#ifdef HAVE_cc0 + if (reg_mentioned_p (cc0_rtx, PATTERN (insn))) + insn = prev_cc0_setter (insn); +#endif + emit_insn_before (seq, insn); } diff --git a/gcc/gcse.c b/gcc/gcse.c index 97ea6d7a884..3482f8faf62 100644 --- a/gcc/gcse.c +++ b/gcc/gcse.c @@ -915,8 +915,9 @@ oprs_unchanged_p (const_rtx x, const_rtx insn, int avail_p) } case MEM: - if (load_killed_in_block_p (current_bb, DF_INSN_LUID (insn), - x, avail_p)) + if (! flag_gcse_lm + || load_killed_in_block_p (current_bb, DF_INSN_LUID (insn), + x, avail_p)) return 0; else return oprs_unchanged_p (XEXP (x, 0), insn, avail_p); @@ -1496,10 +1497,14 @@ canon_list_insert (rtx dest ATTRIBUTE_UNUSED, const_rtx x ATTRIBUTE_UNUSED, static void record_last_mem_set_info (rtx insn) { - int bb = BLOCK_FOR_INSN (insn)->index; + int bb; + + if (! flag_gcse_lm) + return; /* load_killed_in_block_p will handle the case of calls clobbering everything. */ + bb = BLOCK_FOR_INSN (insn)->index; modify_mem_list[bb].safe_push (insn); bitmap_set_bit (modify_mem_list_set, bb); diff --git a/gcc/genmultilib b/gcc/genmultilib index 4dca65d68ff..3e6046b9627 100644 --- a/gcc/genmultilib +++ b/gcc/genmultilib @@ -267,6 +267,7 @@ fi # names. toosdirnames= defaultosdirname= +defaultosdirname2= if [ -n "${multiarch}" ]; then defaultosdirname=::${multiarch} fi @@ -280,6 +281,13 @@ if [ -n "${osdirnames}" ]; then if [ -n "${multiarch}" ]; then defaultosdirname=${defaultosdirname}:${multiarch} fi + case "$defaultosdirname" in + ::*) ;; + *) + defaultosdirname2=${defaultosdirname} + defaultosdirname= + ;; + esac shift ;; *=*) @@ -352,6 +360,7 @@ for set in ${options}; do done optout=`echo ${optout} | sed -e 's/^ //'` echo "\".${defaultosdirname} ${optout};\"," +[ -n "${defaultosdirname2}" ] && echo "\".${defaultosdirname2} ${optout};\"," # This part of code convert an option combination to # its corresponding directory names. diff --git a/gcc/gimple.h b/gcc/gimple.h index 7b5e741eb33..9f72e6776cc 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -2800,23 +2800,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/gimplify.c b/gcc/gimplify.c index 1018257c7d0..1f7b3da29fc 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -4903,7 +4903,7 @@ gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, if (!DECL_NAME (*from_p) && DECL_NAME (*to_p)) DECL_NAME (*from_p) = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p))); - DECL_DEBUG_EXPR_IS_FROM (*from_p) = 1; + DECL_HAS_DEBUG_EXPR_P (*from_p) = 1; SET_DECL_DEBUG_EXPR (*from_p, *to_p); } diff --git a/gcc/graph.c b/gcc/graph.c index 51837308bb4..1ecfdf0b761 100644 --- a/gcc/graph.c +++ b/gcc/graph.c @@ -213,7 +213,8 @@ draw_cfg_nodes_for_loop (pretty_printer *pp, int funcdef_no, unsigned int i; const char *fillcolors[3] = { "grey88", "grey77", "grey66" }; - if (loop->latch != EXIT_BLOCK_PTR) + if (loop->header != NULL + && loop->latch != EXIT_BLOCK_PTR) pp_printf (pp, "\tsubgraph cluster_%d_%d {\n" "\tstyle=\"filled\";\n" @@ -229,6 +230,9 @@ draw_cfg_nodes_for_loop (pretty_printer *pp, int funcdef_no, for (struct loop *inner = loop->inner; inner; inner = inner->next) draw_cfg_nodes_for_loop (pp, funcdef_no, inner); + if (loop->header == NULL) + return; + if (loop->latch == EXIT_BLOCK_PTR) body = get_loop_body (loop); else diff --git a/gcc/hw-doloop.c b/gcc/hw-doloop.c index 2f54f4e1c0b..9b59f5ddc6d 100644 --- a/gcc/hw-doloop.c +++ b/gcc/hw-doloop.c @@ -365,7 +365,7 @@ discover_loops (bitmap_obstack *loop_stack, struct hw_doloop_hooks *hooks) rtx tail = BB_END (bb); rtx insn, reg; - while (tail && GET_CODE (tail) == NOTE && tail != BB_HEAD (bb)) + while (tail && NOTE_P (tail) && tail != BB_HEAD (bb)) tail = PREV_INSN (tail); if (tail == NULL_RTX) diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index d01b053a3f9..69d7d23acb2 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -1622,9 +1622,12 @@ devirtualization_time_bonus (struct cgraph_node *node, static int hint_time_bonus (inline_hints hints) { + int result = 0; if (hints & (INLINE_HINT_loop_iterations | INLINE_HINT_loop_stride)) - return PARAM_VALUE (PARAM_IPA_CP_LOOP_HINT_BONUS); - return 0; + result += PARAM_VALUE (PARAM_IPA_CP_LOOP_HINT_BONUS); + if (hints & INLINE_HINT_array_index) + result += PARAM_VALUE (PARAM_IPA_CP_ARRAY_INDEX_HINT_BONUS); + return result; } /* Return true if cloning NODE is a good idea, given the estimated TIME_BENEFIT 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/is-a.h b/gcc/is-a.h index 8b7f9b34dde..b5ee8543abe 100644 --- a/gcc/is-a.h +++ b/gcc/is-a.h @@ -181,7 +181,7 @@ template <typename T, typename U> inline T * as_a (U *p) { - gcc_assert (is_a <T> (p)); + gcc_checking_assert (is_a <T> (p)); return is_a_helper <T>::cast (p); } diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index c6d0675231d..29db4eb2669 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,7 @@ +2013-03-22 Kai Tietz <ktietz@redhat.com> + + * lang.c (put_decl_node): Don't iterate over end_params_node. + 2013-01-03 Jakub Jelinek <jakub@redhat.com> * jcf-dump.c (version): Update copyright notice dates. diff --git a/gcc/java/lang.c b/gcc/java/lang.c index fd9364df1d4..d40af8722b5 100644 --- a/gcc/java/lang.c +++ b/gcc/java/lang.c @@ -419,7 +419,8 @@ put_decl_node (tree node, int verbosity) if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE) args = TREE_CHAIN (args); put_decl_string ("(", 1); - for ( ; args != end_params_node; args = TREE_CHAIN (args), i++) + for ( ; args != NULL_TREE && args != end_params_node; + args = TREE_CHAIN (args), i++) { if (i > 0) put_decl_string (",", 1); 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/loop-iv.c b/gcc/loop-iv.c index bf7f721f926..d4ecd0e014f 100644 --- a/gcc/loop-iv.c +++ b/gcc/loop-iv.c @@ -1505,19 +1505,26 @@ implies_p (rtx a, rtx b) rtx op0, op1, opb0, opb1, r; enum machine_mode mode; + if (rtx_equal_p (a, b)) + return true; + if (GET_CODE (a) == EQ) { op0 = XEXP (a, 0); op1 = XEXP (a, 1); - if (REG_P (op0)) + if (REG_P (op0) + || (GET_CODE (op0) == SUBREG + && REG_P (SUBREG_REG (op0)))) { r = simplify_replace_rtx (b, op0, op1); if (r == const_true_rtx) return true; } - if (REG_P (op1)) + if (REG_P (op1) + || (GET_CODE (op1) == SUBREG + && REG_P (SUBREG_REG (op1)))) { r = simplify_replace_rtx (b, op1, op0); if (r == const_true_rtx) diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c index 20b7a8e5443..5bb734090a0 100644 --- a/gcc/lto-streamer-out.c +++ b/gcc/lto-streamer-out.c @@ -1264,17 +1264,36 @@ bool output_symbol_p (symtab_node node) { struct cgraph_node *cnode; - struct ipa_ref *ref; - if (!symtab_real_symbol_p (node)) return false; /* We keep external functions in symtab for sake of inlining and devirtualization. We do not want to see them in symbol table as - references. */ + references unless they are really used. */ cnode = dyn_cast <cgraph_node> (node); - if (cnode && DECL_EXTERNAL (cnode->symbol.decl)) - return (cnode->callers - || ipa_ref_list_referring_iterate (&cnode->symbol.ref_list, 0, ref)); + if (cnode && DECL_EXTERNAL (cnode->symbol.decl) + && cnode->callers) + return true; + + /* Ignore all references from external vars initializers - they are not really + part of the compilation unit until they are used by folding. Some symbols, + like references to external construction vtables can not be referred to at all. + We decide this at can_refer_decl_in_current_unit_p. */ + if (DECL_EXTERNAL (node->symbol.decl)) + { + int i; + struct ipa_ref *ref; + for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list, + i, ref); i++) + { + if (ref->use == IPA_REF_ALIAS) + continue; + if (is_a <cgraph_node> (ref->referring)) + return true; + if (!DECL_EXTERNAL (ref->referring->symbol.decl)) + return true; + } + return false; + } return true; } diff --git a/gcc/params.def b/gcc/params.def index 97d48574587..a25b8bce1dd 100644 --- a/gcc/params.def +++ b/gcc/params.def @@ -919,6 +919,12 @@ DEFPARAM (PARAM_IPA_CP_LOOP_HINT_BONUS, "bounds or strides known.", 64, 0, 0) +DEFPARAM (PARAM_IPA_CP_ARRAY_INDEX_HINT_BONUS, + "ipa-cp-array-index-hint-bonus", + "Compile-time bonus IPA-CP assigns to candidates which make an array " + "index known.", + 48, 0, 0) + /* WHOPR partitioning configuration. */ DEFPARAM (PARAM_LTO_PARTITIONS, diff --git a/gcc/passes.c b/gcc/passes.c index 968909997d2..ede5013974a 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -1315,7 +1315,6 @@ init_optimization_passes (void) NEXT_PASS (pass_expand_omp); NEXT_PASS (pass_build_ssa); - NEXT_PASS (pass_lower_vector); NEXT_PASS (pass_early_warn_uninitialized); NEXT_PASS (pass_rebuild_cgraph_edges); NEXT_PASS (pass_inline_parameters); @@ -1493,7 +1492,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 @@ -1502,6 +1500,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); @@ -1559,6 +1558,7 @@ init_optimization_passes (void) NEXT_PASS (pass_tm_memopt); NEXT_PASS (pass_tm_edges); } + NEXT_PASS (pass_lower_vector); NEXT_PASS (pass_lower_complex_O0); NEXT_PASS (pass_asan_O0); NEXT_PASS (pass_tsan_O0); @@ -2776,6 +2776,8 @@ dump_properties (FILE *dump, unsigned int props) fprintf (dump, "PROP_gimple_lomp\n"); if (props & PROP_gimple_lcx) fprintf (dump, "PROP_gimple_lcx\n"); + if (props & PROP_gimple_lvec) + fprintf (dump, "PROP_gimple_lvec\n"); if (props & PROP_cfglayout) fprintf (dump, "PROP_cfglayout\n"); } diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog index 128fa19ce4e..1f2e5257604 100644 --- a/gcc/po/ChangeLog +++ b/gcc/po/ChangeLog @@ -1,3 +1,11 @@ +2013-03-17 Joseph Myers <joseph@codesourcery.com> + + * sv.po: Update. + +2013-03-15 Joseph Myers <joseph@codesourcery.com> + + * gcc.pot: Regenerate. + 2013-03-11 Joseph Myers <joseph@codesourcery.com> * de.po, sv.po: Update. diff --git a/gcc/po/gcc.pot b/gcc/po/gcc.pot index 94832661424..0797abfe011 100644 --- a/gcc/po/gcc.pot +++ b/gcc/po/gcc.pot @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" -"POT-Creation-Date: 2013-02-24 01:09+0000\n" +"POT-Creation-Date: 2013-03-15 17:42+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" "Language-Team: LANGUAGE <LL@li.org>\n" @@ -18,19 +18,19 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n" -#: cfgrtl.c:2320 +#: cfgrtl.c:2318 msgid "flow control insn inside a basic block" msgstr "" -#: cfgrtl.c:2448 +#: cfgrtl.c:2446 msgid "wrong insn in the fallthru edge" msgstr "" -#: cfgrtl.c:2502 +#: cfgrtl.c:2500 msgid "insn outside basic block" msgstr "" -#: cfgrtl.c:2509 +#: cfgrtl.c:2507 msgid "return not followed by barrier" msgstr "" @@ -130,7 +130,7 @@ msgstr "" msgid "%s:%d: confused by earlier errors, bailing out\n" msgstr "" -#: diagnostic.c:1126 +#: diagnostic.c:1129 #, c-format msgid "Internal compiler error: Error reporting routines re-entered.\n" msgstr "" @@ -193,278 +193,278 @@ msgstr "" msgid "invalid expression as operand" msgstr "" -#: gcc.c:1402 +#: gcc.c:1403 #, c-format msgid "Using built-in specs.\n" msgstr "" -#: gcc.c:1599 +#: gcc.c:1600 #, c-format msgid "" "Setting spec %s to '%s'\n" "\n" msgstr "" -#: gcc.c:1708 +#: gcc.c:1709 #, c-format msgid "Reading specs from %s\n" msgstr "" -#: gcc.c:1833 +#: gcc.c:1834 #, c-format msgid "could not find specs file %s\n" msgstr "" -#: gcc.c:1902 +#: gcc.c:1903 #, c-format msgid "rename spec %s to %s\n" msgstr "" -#: gcc.c:1904 +#: gcc.c:1905 #, c-format msgid "" "spec is '%s'\n" "\n" msgstr "" -#: gcc.c:2337 +#: gcc.c:2338 #, c-format msgid "%s\n" msgstr "" -#: gcc.c:2704 +#: gcc.c:2705 #, c-format msgid "" "\n" "Go ahead? (y or n) " msgstr "" -#: gcc.c:2844 +#: gcc.c:2845 #, c-format msgid "# %s %.2f %.2f\n" msgstr "" -#: gcc.c:3047 +#: gcc.c:3048 #, c-format msgid "Usage: %s [options] file...\n" msgstr "" -#: gcc.c:3048 +#: gcc.c:3049 msgid "Options:\n" msgstr "" -#: gcc.c:3050 +#: gcc.c:3051 msgid " -pass-exit-codes Exit with highest error code from a phase\n" msgstr "" -#: gcc.c:3051 +#: gcc.c:3052 msgid " --help Display this information\n" msgstr "" -#: gcc.c:3052 +#: gcc.c:3053 msgid "" " --target-help Display target specific command line options\n" msgstr "" -#: gcc.c:3053 +#: gcc.c:3054 msgid "" " --help={common|optimizers|params|target|warnings|[^]{joined|separate|" "undocumented}}[,...]\n" msgstr "" -#: gcc.c:3054 +#: gcc.c:3055 msgid "" " Display specific types of command line options\n" msgstr "" -#: gcc.c:3056 +#: gcc.c:3057 msgid " (Use '-v --help' to display command line options of sub-processes)\n" msgstr "" -#: gcc.c:3057 +#: gcc.c:3058 msgid " --version Display compiler version information\n" msgstr "" -#: gcc.c:3058 +#: gcc.c:3059 msgid " -dumpspecs Display all of the built in spec strings\n" msgstr "" -#: gcc.c:3059 +#: gcc.c:3060 msgid " -dumpversion Display the version of the compiler\n" msgstr "" -#: gcc.c:3060 +#: gcc.c:3061 msgid " -dumpmachine Display the compiler's target processor\n" msgstr "" -#: gcc.c:3061 +#: gcc.c:3062 msgid "" " -print-search-dirs Display the directories in the compiler's search " "path\n" msgstr "" -#: gcc.c:3062 +#: gcc.c:3063 msgid "" " -print-libgcc-file-name Display the name of the compiler's companion " "library\n" msgstr "" -#: gcc.c:3063 +#: gcc.c:3064 msgid " -print-file-name=<lib> Display the full path to library <lib>\n" msgstr "" -#: gcc.c:3064 +#: gcc.c:3065 msgid "" " -print-prog-name=<prog> Display the full path to compiler component " "<prog>\n" msgstr "" -#: gcc.c:3065 +#: gcc.c:3066 msgid "" " -print-multiarch Display the target's normalized GNU triplet, used " "as\n" " a component in the library path\n" msgstr "" -#: gcc.c:3068 +#: gcc.c:3069 msgid "" " -print-multi-directory Display the root directory for versions of " "libgcc\n" msgstr "" -#: gcc.c:3069 +#: gcc.c:3070 msgid "" " -print-multi-lib Display the mapping between command line options " "and\n" " multiple library search directories\n" msgstr "" -#: gcc.c:3072 +#: gcc.c:3073 msgid " -print-multi-os-directory Display the relative path to OS libraries\n" msgstr "" -#: gcc.c:3073 +#: gcc.c:3074 msgid " -print-sysroot Display the target libraries directory\n" msgstr "" -#: gcc.c:3074 +#: gcc.c:3075 msgid "" " -print-sysroot-headers-suffix Display the sysroot suffix used to find " "headers\n" msgstr "" -#: gcc.c:3075 +#: gcc.c:3076 msgid "" " -Wa,<options> Pass comma-separated <options> on to the " "assembler\n" msgstr "" -#: gcc.c:3076 +#: gcc.c:3077 msgid "" " -Wp,<options> Pass comma-separated <options> on to the " "preprocessor\n" msgstr "" -#: gcc.c:3077 +#: gcc.c:3078 msgid "" " -Wl,<options> Pass comma-separated <options> on to the linker\n" msgstr "" -#: gcc.c:3078 +#: gcc.c:3079 msgid " -Xassembler <arg> Pass <arg> on to the assembler\n" msgstr "" -#: gcc.c:3079 +#: gcc.c:3080 msgid " -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n" msgstr "" -#: gcc.c:3080 +#: gcc.c:3081 msgid " -Xlinker <arg> Pass <arg> on to the linker\n" msgstr "" -#: gcc.c:3081 +#: gcc.c:3082 msgid " -save-temps Do not delete intermediate files\n" msgstr "" -#: gcc.c:3082 +#: gcc.c:3083 msgid " -save-temps=<arg> Do not delete intermediate files\n" msgstr "" -#: gcc.c:3083 +#: gcc.c:3084 msgid "" " -no-canonical-prefixes Do not canonicalize paths when building relative\n" " prefixes to other gcc components\n" msgstr "" -#: gcc.c:3086 +#: gcc.c:3087 msgid " -pipe Use pipes rather than intermediate files\n" msgstr "" -#: gcc.c:3087 +#: gcc.c:3088 msgid " -time Time the execution of each subprocess\n" msgstr "" -#: gcc.c:3088 +#: gcc.c:3089 msgid "" " -specs=<file> Override built-in specs with the contents of " "<file>\n" msgstr "" -#: gcc.c:3089 +#: gcc.c:3090 msgid "" " -std=<standard> Assume that the input sources are for <standard>\n" msgstr "" -#: gcc.c:3090 +#: gcc.c:3091 msgid "" " --sysroot=<directory> Use <directory> as the root directory for " "headers\n" " and libraries\n" msgstr "" -#: gcc.c:3093 +#: gcc.c:3094 msgid "" " -B <directory> Add <directory> to the compiler's search paths\n" msgstr "" -#: gcc.c:3094 +#: gcc.c:3095 msgid "" " -v Display the programs invoked by the compiler\n" msgstr "" -#: gcc.c:3095 +#: gcc.c:3096 msgid "" " -### Like -v but options quoted and commands not " "executed\n" msgstr "" -#: gcc.c:3096 +#: gcc.c:3097 msgid "" " -E Preprocess only; do not compile, assemble or " "link\n" msgstr "" -#: gcc.c:3097 +#: gcc.c:3098 msgid " -S Compile only; do not assemble or link\n" msgstr "" -#: gcc.c:3098 +#: gcc.c:3099 msgid " -c Compile and assemble, but do not link\n" msgstr "" -#: gcc.c:3099 +#: gcc.c:3100 msgid " -o <file> Place the output into <file>\n" msgstr "" -#: gcc.c:3100 +#: gcc.c:3101 msgid " -pie Create a position independent executable\n" msgstr "" -#: gcc.c:3101 +#: gcc.c:3102 msgid " -shared Create a shared library\n" msgstr "" -#: gcc.c:3102 +#: gcc.c:3103 msgid "" " -x <language> Specify the language of the following input " "files\n" @@ -475,7 +475,7 @@ msgid "" "extension\n" msgstr "" -#: gcc.c:3109 +#: gcc.c:3110 #, c-format msgid "" "\n" @@ -484,43 +484,43 @@ msgid "" " other options on to these processes the -W<letter> options must be used.\n" msgstr "" -#: gcc.c:5364 +#: gcc.c:5365 #, c-format msgid "Processing spec (%s), which is '%s'\n" msgstr "" -#: gcc.c:6649 +#: gcc.c:6651 #, c-format msgid "install: %s%s\n" msgstr "" -#: gcc.c:6652 +#: gcc.c:6654 #, c-format msgid "programs: %s\n" msgstr "" -#: gcc.c:6654 +#: gcc.c:6656 #, c-format msgid "libraries: %s\n" msgstr "" -#: gcc.c:6738 +#: gcc.c:6740 #, c-format msgid "" "\n" "For bug reporting instructions, please see:\n" msgstr "" -#: gcc.c:6754 +#: gcc.c:6756 #, c-format msgid "%s %s%s\n" msgstr "" -#: gcc.c:6757 gcov.c:491 fortran/gfortranspec.c:303 java/jcf-dump.c:1230 +#: gcc.c:6759 gcov.c:491 fortran/gfortranspec.c:303 java/jcf-dump.c:1230 msgid "(C)" msgstr "" -#: gcc.c:6758 java/jcf-dump.c:1231 +#: gcc.c:6760 java/jcf-dump.c:1231 #, c-format msgid "" "This is free software; see the source for copying conditions. There is NO\n" @@ -528,32 +528,32 @@ msgid "" "\n" msgstr "" -#: gcc.c:6775 +#: gcc.c:6777 #, c-format msgid "Target: %s\n" msgstr "" -#: gcc.c:6776 +#: gcc.c:6778 #, c-format msgid "Configured with: %s\n" msgstr "" -#: gcc.c:6790 +#: gcc.c:6792 #, c-format msgid "Thread model: %s\n" msgstr "" -#: gcc.c:6801 +#: gcc.c:6803 #, c-format msgid "gcc version %s %s\n" msgstr "" -#: gcc.c:6804 +#: gcc.c:6806 #, c-format msgid "gcc driver version %s %sexecuting gcc version %s\n" msgstr "" -#: gcc.c:7058 +#: gcc.c:7061 #, c-format msgid "" "\n" @@ -562,14 +562,14 @@ msgid "" "\n" msgstr "" -#: gcc.c:7059 +#: gcc.c:7062 #, c-format msgid "" "Use \"-Wl,OPTION\" to pass \"OPTION\" to the linker.\n" "\n" msgstr "" -#: gcc.c:8276 +#: gcc.c:8279 #, c-format msgid "" "Assembler options\n" @@ -577,7 +577,7 @@ msgid "" "\n" msgstr "" -#: gcc.c:8277 +#: gcc.c:8280 #, c-format msgid "" "Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n" @@ -995,17 +995,17 @@ msgstr "" msgid "ignoring nonexistent directory \"%s\"\n" msgstr "" -#: incpath.c:363 +#: incpath.c:374 #, c-format msgid "#include \"...\" search starts here:\n" msgstr "" -#: incpath.c:367 +#: incpath.c:378 #, c-format msgid "#include <...> search starts here:\n" msgstr "" -#: incpath.c:372 +#: incpath.c:383 #, c-format msgid "End of search list.\n" msgstr "" @@ -1038,44 +1038,44 @@ msgstr "" msgid "At top level:" msgstr "" -#: langhooks.c:400 cp/error.c:3038 +#: langhooks.c:400 cp/error.c:3042 #, c-format msgid "In member function %qs" msgstr "" -#: langhooks.c:404 cp/error.c:3041 +#: langhooks.c:404 cp/error.c:3045 #, c-format msgid "In function %qs" msgstr "" -#: langhooks.c:455 cp/error.c:2991 +#: langhooks.c:455 cp/error.c:2995 #, c-format msgid " inlined from %qs at %s:%d:%d" msgstr "" -#: langhooks.c:460 cp/error.c:2996 +#: langhooks.c:460 cp/error.c:3000 #, c-format msgid " inlined from %qs at %s:%d" msgstr "" -#: langhooks.c:466 cp/error.c:3002 +#: langhooks.c:466 cp/error.c:3006 #, c-format msgid " inlined from %qs" msgstr "" -#: loop-iv.c:3029 tree-ssa-loop-niter.c:1924 +#: loop-iv.c:3029 tree-ssa-loop-niter.c:1925 msgid "assuming that the loop is not infinite" msgstr "" -#: loop-iv.c:3030 tree-ssa-loop-niter.c:1925 +#: loop-iv.c:3030 tree-ssa-loop-niter.c:1926 msgid "cannot optimize possibly infinite loops" msgstr "" -#: loop-iv.c:3038 tree-ssa-loop-niter.c:1929 +#: loop-iv.c:3038 tree-ssa-loop-niter.c:1930 msgid "assuming that the loop counter does not overflow" msgstr "" -#: loop-iv.c:3039 tree-ssa-loop-niter.c:1930 +#: loop-iv.c:3039 tree-ssa-loop-niter.c:1931 msgid "cannot optimize loop, the loop counter may overflow" msgstr "" @@ -1153,81 +1153,81 @@ msgstr "" msgid "This switch lacks documentation" msgstr "" -#: opts.c:1015 +#: opts.c:1018 msgid "[default]" msgstr "" -#: opts.c:1026 +#: opts.c:1029 msgid "[enabled]" msgstr "" -#: opts.c:1026 +#: opts.c:1029 msgid "[disabled]" msgstr "" -#: opts.c:1045 +#: opts.c:1048 #, c-format msgid " No options with the desired characteristics were found\n" msgstr "" -#: opts.c:1054 +#: opts.c:1057 #, c-format msgid "" " None found. Use --help=%s to show *all* the options supported by the %s " "front-end\n" msgstr "" -#: opts.c:1060 +#: opts.c:1063 #, c-format msgid "" " All options with the desired characteristics have already been displayed\n" msgstr "" -#: opts.c:1155 +#: opts.c:1158 msgid "The following options are target specific" msgstr "" -#: opts.c:1158 +#: opts.c:1161 msgid "The following options control compiler warning messages" msgstr "" -#: opts.c:1161 +#: opts.c:1164 msgid "The following options control optimizations" msgstr "" -#: opts.c:1164 opts.c:1203 +#: opts.c:1167 opts.c:1206 msgid "The following options are language-independent" msgstr "" -#: opts.c:1167 +#: opts.c:1170 msgid "The --param option recognizes the following as parameters" msgstr "" -#: opts.c:1173 +#: opts.c:1176 msgid "The following options are specific to just the language " msgstr "" -#: opts.c:1175 +#: opts.c:1178 msgid "The following options are supported by the language " msgstr "" -#: opts.c:1186 +#: opts.c:1189 msgid "The following options are not documented" msgstr "" -#: opts.c:1188 +#: opts.c:1191 msgid "The following options take separate arguments" msgstr "" -#: opts.c:1190 +#: opts.c:1193 msgid "The following options take joined arguments" msgstr "" -#: opts.c:1201 +#: opts.c:1204 msgid "The following options are language-related" msgstr "" -#: opts.c:2078 +#: opts.c:2081 msgid "enabled by default" msgstr "" @@ -2551,7 +2551,7 @@ msgstr "" msgid "<return-value>" msgstr "" -#: c-family/c-pretty-print.c:2147 cp/error.c:1818 cp/error.c:2764 +#: c-family/c-pretty-print.c:2147 cp/error.c:1818 cp/error.c:2768 msgid "<unknown>" msgstr "" @@ -2569,7 +2569,7 @@ msgstr "" msgid "incompatible floating point / vector register operand for '%%%c'" msgstr "" -#: config/aarch64/aarch64.c:3399 config/arm/arm.c:18223 +#: config/aarch64/aarch64.c:3399 config/arm/arm.c:18233 #, c-format msgid "missing operand" msgstr "" @@ -2673,33 +2673,34 @@ msgstr "" msgid "invalid %%xn code" msgstr "" -#: config/arm/arm.c:17560 config/arm/arm.c:17578 +#: config/arm/arm.c:15438 config/arm/arm.c:15463 config/arm/arm.c:15473 +#: config/arm/arm.c:15482 config/arm/arm.c:15490 #, c-format -msgid "predicated Thumb instruction" +msgid "invalid shift operand" msgstr "" -#: config/arm/arm.c:17566 +#: config/arm/arm.c:17576 config/arm/arm.c:17594 #, c-format -msgid "predicated instruction in conditional sequence" +msgid "predicated Thumb instruction" msgstr "" -#: config/arm/arm.c:17697 config/arm/arm.c:17710 +#: config/arm/arm.c:17582 #, c-format -msgid "Unsupported operand for code '%c'" +msgid "predicated instruction in conditional sequence" msgstr "" -#: config/arm/arm.c:17748 +#: config/arm/arm.c:17713 config/arm/arm.c:17726 #, c-format -msgid "invalid shift operand" +msgid "Unsupported operand for code '%c'" msgstr "" -#: config/arm/arm.c:17805 config/arm/arm.c:17827 config/arm/arm.c:17837 -#: config/arm/arm.c:17847 config/arm/arm.c:17857 config/arm/arm.c:17896 -#: config/arm/arm.c:17914 config/arm/arm.c:17939 config/arm/arm.c:17954 -#: config/arm/arm.c:17981 config/arm/arm.c:17988 config/arm/arm.c:18006 -#: config/arm/arm.c:18013 config/arm/arm.c:18021 config/arm/arm.c:18042 -#: config/arm/arm.c:18049 config/arm/arm.c:18174 config/arm/arm.c:18181 -#: config/arm/arm.c:18204 config/arm/arm.c:18211 config/bfin/bfin.c:1439 +#: config/arm/arm.c:17815 config/arm/arm.c:17837 config/arm/arm.c:17847 +#: config/arm/arm.c:17857 config/arm/arm.c:17867 config/arm/arm.c:17906 +#: config/arm/arm.c:17924 config/arm/arm.c:17949 config/arm/arm.c:17964 +#: config/arm/arm.c:17991 config/arm/arm.c:17998 config/arm/arm.c:18016 +#: config/arm/arm.c:18023 config/arm/arm.c:18031 config/arm/arm.c:18052 +#: config/arm/arm.c:18059 config/arm/arm.c:18184 config/arm/arm.c:18191 +#: config/arm/arm.c:18214 config/arm/arm.c:18221 config/bfin/bfin.c:1439 #: config/bfin/bfin.c:1446 config/bfin/bfin.c:1453 config/bfin/bfin.c:1460 #: config/bfin/bfin.c:1469 config/bfin/bfin.c:1476 config/bfin/bfin.c:1483 #: config/bfin/bfin.c:1490 @@ -2707,22 +2708,22 @@ msgstr "" msgid "invalid operand for code '%c'" msgstr "" -#: config/arm/arm.c:17909 +#: config/arm/arm.c:17919 #, c-format msgid "instruction never executed" msgstr "" #. Former Maverick support, removed after GCC-4.7. -#: config/arm/arm.c:17930 +#: config/arm/arm.c:17940 #, c-format msgid "obsolete Maverick format code '%c'" msgstr "" -#: config/arm/arm.c:20988 +#: config/arm/arm.c:20998 msgid "function parameters cannot have __fp16 type" msgstr "" -#: config/arm/arm.c:20998 +#: config/arm/arm.c:21008 msgid "functions cannot return __fp16 type" msgstr "" @@ -2757,7 +2758,7 @@ msgstr "" #: config/avr/avr.c:2234 #, c-format -msgid "Unsupported code '%c'for fixed-point:" +msgid "Unsupported code '%c' for fixed-point:" msgstr "" #: config/avr/avr.c:2243 @@ -2804,8 +2805,8 @@ msgid "invalid const_double operand" msgstr "" #: config/cris/cris.c:580 config/moxie/moxie.c:111 final.c:3311 final.c:3313 -#: fold-const.c:270 gcc.c:4712 gcc.c:4726 loop-iv.c:3031 loop-iv.c:3040 -#: rtl-error.c:102 toplev.c:332 tree-ssa-loop-niter.c:1933 tree-vrp.c:6783 +#: fold-const.c:270 gcc.c:4713 gcc.c:4727 loop-iv.c:3031 loop-iv.c:3040 +#: rtl-error.c:102 toplev.c:332 tree-ssa-loop-niter.c:1934 tree-vrp.c:6783 #: cp/typeck.c:5618 java/expr.c:389 lto/lto-object.c:189 lto/lto-object.c:287 #: lto/lto-object.c:344 lto/lto-object.c:368 #, gcc-internal-format, gfc-internal-format @@ -3147,8 +3148,8 @@ msgstr "" msgid "invalid operation on %<__fpreg%>" msgstr "" -#: config/iq2000/iq2000.c:3132 config/tilegx/tilegx.c:5205 -#: config/tilepro/tilepro.c:4695 +#: config/iq2000/iq2000.c:3132 config/tilegx/tilegx.c:5203 +#: config/tilepro/tilepro.c:4693 #, c-format msgid "invalid %%P operand" msgstr "" @@ -3163,20 +3164,20 @@ msgstr "" msgid "invalid use of %%d, %%x, or %%X" msgstr "" -#: config/lm32/lm32.c:521 +#: config/lm32/lm32.c:518 #, c-format msgid "only 0.0 can be loaded as an immediate" msgstr "" -#: config/lm32/lm32.c:591 +#: config/lm32/lm32.c:588 msgid "bad operand" msgstr "" -#: config/lm32/lm32.c:603 +#: config/lm32/lm32.c:600 msgid "can't use non gp relative absolute address" msgstr "" -#: config/lm32/lm32.c:607 +#: config/lm32/lm32.c:604 msgid "invalid addressing mode" msgstr "" @@ -3245,36 +3246,36 @@ msgstr "" msgid "invalid %%L code" msgstr "" -#: config/microblaze/microblaze.c:1760 +#: config/microblaze/microblaze.c:2156 #, c-format msgid "unknown punctuation '%c'" msgstr "" -#: config/microblaze/microblaze.c:1769 +#: config/microblaze/microblaze.c:2165 #, c-format msgid "null pointer" msgstr "" -#: config/microblaze/microblaze.c:1804 +#: config/microblaze/microblaze.c:2200 #, c-format msgid "PRINT_OPERAND, invalid insn for %%C" msgstr "" -#: config/microblaze/microblaze.c:1833 +#: config/microblaze/microblaze.c:2229 #, c-format msgid "PRINT_OPERAND, invalid insn for %%N" msgstr "" -#: config/microblaze/microblaze.c:1853 config/microblaze/microblaze.c:2014 +#: config/microblaze/microblaze.c:2249 config/microblaze/microblaze.c:2420 msgid "insn contains an invalid address !" msgstr "" -#: config/microblaze/microblaze.c:1867 config/microblaze/microblaze.c:2054 +#: config/microblaze/microblaze.c:2264 config/microblaze/microblaze.c:2479 #: config/xtensa/xtensa.c:2443 msgid "invalid address" msgstr "" -#: config/microblaze/microblaze.c:1966 +#: config/microblaze/microblaze.c:2363 #, c-format msgid "letter %c was found & insn was not CONST_INT" msgstr "" @@ -3555,25 +3556,25 @@ msgstr "" msgid "invalid operand for code: '%c'" msgstr "" -#: config/sh/sh.c:1204 +#: config/sh/sh.c:1201 #, c-format msgid "invalid operand to %%R" msgstr "" -#: config/sh/sh.c:1231 +#: config/sh/sh.c:1228 #, c-format msgid "invalid operand to %%S" msgstr "" -#: config/sh/sh.c:9775 +#: config/sh/sh.c:9772 msgid "created and used with different architectures / ABIs" msgstr "" -#: config/sh/sh.c:9777 +#: config/sh/sh.c:9774 msgid "created and used with different ABIs" msgstr "" -#: config/sh/sh.c:9779 +#: config/sh/sh.c:9776 msgid "created and used with different endianness" msgstr "" @@ -3592,13 +3593,13 @@ msgstr "" msgid "invalid %%B operand" msgstr "" -#: config/sparc/sparc.c:8508 config/tilegx/tilegx.c:4988 -#: config/tilepro/tilepro.c:4498 +#: config/sparc/sparc.c:8508 config/tilegx/tilegx.c:4986 +#: config/tilepro/tilepro.c:4496 #, c-format msgid "invalid %%C operand" msgstr "" -#: config/sparc/sparc.c:8525 config/tilegx/tilegx.c:5021 +#: config/sparc/sparc.c:8525 config/tilegx/tilegx.c:5019 #, c-format msgid "invalid %%D operand" msgstr "" @@ -3643,87 +3644,87 @@ msgstr "" msgid "xstormy16_print_operand: unknown code" msgstr "" -#: config/tilegx/tilegx.c:4973 config/tilepro/tilepro.c:4483 +#: config/tilegx/tilegx.c:4971 config/tilepro/tilepro.c:4481 #, c-format msgid "invalid %%c operand" msgstr "" -#: config/tilegx/tilegx.c:5004 +#: config/tilegx/tilegx.c:5002 #, c-format msgid "invalid %%d operand" msgstr "" -#: config/tilegx/tilegx.c:5101 +#: config/tilegx/tilegx.c:5099 #, c-format msgid "invalid %%H specifier" msgstr "" -#: config/tilegx/tilegx.c:5143 config/tilepro/tilepro.c:4512 +#: config/tilegx/tilegx.c:5141 config/tilepro/tilepro.c:4510 #, c-format msgid "invalid %%h operand" msgstr "" -#: config/tilegx/tilegx.c:5155 config/tilepro/tilepro.c:4576 +#: config/tilegx/tilegx.c:5153 config/tilepro/tilepro.c:4574 #, c-format msgid "invalid %%I operand" msgstr "" -#: config/tilegx/tilegx.c:5169 config/tilepro/tilepro.c:4590 +#: config/tilegx/tilegx.c:5167 config/tilepro/tilepro.c:4588 #, c-format msgid "invalid %%i operand" msgstr "" -#: config/tilegx/tilegx.c:5192 config/tilepro/tilepro.c:4613 +#: config/tilegx/tilegx.c:5190 config/tilepro/tilepro.c:4611 #, c-format msgid "invalid %%j operand" msgstr "" -#: config/tilegx/tilegx.c:5223 +#: config/tilegx/tilegx.c:5221 #, c-format msgid "invalid %%%c operand" msgstr "" -#: config/tilegx/tilegx.c:5238 config/tilepro/tilepro.c:4727 +#: config/tilegx/tilegx.c:5236 config/tilepro/tilepro.c:4725 #, c-format msgid "invalid %%N operand" msgstr "" -#: config/tilegx/tilegx.c:5282 +#: config/tilegx/tilegx.c:5280 #, c-format msgid "invalid operand for 'r' specifier" msgstr "" -#: config/tilegx/tilegx.c:5307 config/tilepro/tilepro.c:4809 +#: config/tilegx/tilegx.c:5305 config/tilepro/tilepro.c:4807 #, c-format msgid "unable to print out operand yet; code == %d (%c)" msgstr "" -#: config/tilepro/tilepro.c:4548 +#: config/tilepro/tilepro.c:4546 #, c-format msgid "invalid %%H operand" msgstr "" -#: config/tilepro/tilepro.c:4652 +#: config/tilepro/tilepro.c:4650 #, c-format msgid "invalid %%L operand" msgstr "" -#: config/tilepro/tilepro.c:4712 +#: config/tilepro/tilepro.c:4710 #, c-format msgid "invalid %%M operand" msgstr "" -#: config/tilepro/tilepro.c:4755 +#: config/tilepro/tilepro.c:4753 #, c-format msgid "invalid %%t operand" msgstr "" -#: config/tilepro/tilepro.c:4762 +#: config/tilepro/tilepro.c:4760 #, c-format msgid "invalid %%t operand '" msgstr "" -#: config/tilepro/tilepro.c:4783 +#: config/tilepro/tilepro.c:4781 #, c-format msgid "invalid %%r operand" msgstr "" @@ -3791,7 +3792,7 @@ msgstr "" msgid "({anonymous})" msgstr "" -#: c/c-parser.c:943 cp/parser.c:23010 +#: c/c-parser.c:943 cp/parser.c:23014 #, gcc-internal-format msgid "expected end of line" msgstr "" @@ -3801,8 +3802,8 @@ msgstr "" #: c/c-parser.c:7357 c/c-parser.c:7392 c/c-parser.c:7423 c/c-parser.c:7470 #: c/c-parser.c:7651 c/c-parser.c:8419 c/c-parser.c:8489 c/c-parser.c:8532 #: c/c-parser.c:9810 c/c-parser.c:9825 c/c-parser.c:9834 c/c-parser.c:9979 -#: c/c-parser.c:10018 c/c-parser.c:2500 c/c-parser.c:7644 cp/parser.c:22423 -#: cp/parser.c:22956 +#: c/c-parser.c:10018 c/c-parser.c:2500 c/c-parser.c:7644 cp/parser.c:22427 +#: cp/parser.c:22960 #, gcc-internal-format msgid "expected %<;%>" msgstr "" @@ -3814,13 +3815,13 @@ msgstr "" #: c/c-parser.c:6703 c/c-parser.c:6727 c/c-parser.c:7942 c/c-parser.c:8014 #: c/c-parser.c:8841 c/c-parser.c:8862 c/c-parser.c:8912 c/c-parser.c:9065 #: c/c-parser.c:9144 c/c-parser.c:9228 c/c-parser.c:9942 c/c-parser.c:10766 -#: c/c-parser.c:8985 c/c-parser.c:9010 cp/parser.c:20794 cp/parser.c:22959 +#: c/c-parser.c:8985 c/c-parser.c:9010 cp/parser.c:20798 cp/parser.c:22963 #, gcc-internal-format msgid "expected %<(%>" msgstr "" #: c/c-parser.c:1843 c/c-parser.c:6389 c/c-parser.c:6427 c/c-parser.c:6555 -#: cp/parser.c:22421 cp/parser.c:22974 +#: cp/parser.c:22425 cp/parser.c:22978 #, gcc-internal-format msgid "expected %<,%>" msgstr "" @@ -3836,15 +3837,15 @@ msgstr "" #: c/c-parser.c:7736 c/c-parser.c:7757 c/c-parser.c:7965 c/c-parser.c:8018 #: c/c-parser.c:8391 c/c-parser.c:8844 c/c-parser.c:8865 c/c-parser.c:8943 #: c/c-parser.c:9072 c/c-parser.c:9209 c/c-parser.c:9292 c/c-parser.c:9870 -#: c/c-parser.c:9987 c/c-parser.c:10029 c/c-parser.c:10775 cp/parser.c:20816 -#: cp/parser.c:23004 +#: c/c-parser.c:9987 c/c-parser.c:10029 c/c-parser.c:10775 cp/parser.c:20820 +#: cp/parser.c:23008 #, gcc-internal-format msgid "expected %<)%>" msgstr "" #: c/c-parser.c:3095 c/c-parser.c:3911 c/c-parser.c:3945 c/c-parser.c:5228 #: c/c-parser.c:6491 c/c-parser.c:6760 c/c-parser.c:6878 c/c-parser.c:10678 -#: c/c-parser.c:10680 cp/parser.c:22968 +#: c/c-parser.c:10680 cp/parser.c:22972 #, gcc-internal-format msgid "expected %<]%>" msgstr "" @@ -3853,25 +3854,25 @@ msgstr "" msgid "expected %<;%>, %<,%> or %<)%>" msgstr "" -#: c/c-parser.c:3774 c/c-parser.c:9826 cp/parser.c:22962 cp/parser.c:24780 +#: c/c-parser.c:3774 c/c-parser.c:9826 cp/parser.c:22966 cp/parser.c:24784 #, gcc-internal-format msgid "expected %<}%>" msgstr "" #: c/c-parser.c:4064 c/c-parser.c:7985 c/c-parser.c:10272 c/c-parser.c:2318 -#: c/c-parser.c:2521 c/c-parser.c:7539 cp/parser.c:14644 cp/parser.c:22965 +#: c/c-parser.c:2521 c/c-parser.c:7539 cp/parser.c:14646 cp/parser.c:22969 #, gcc-internal-format msgid "expected %<{%>" msgstr "" #: c/c-parser.c:4283 c/c-parser.c:4292 c/c-parser.c:5135 c/c-parser.c:5469 #: c/c-parser.c:7750 c/c-parser.c:8125 c/c-parser.c:8182 c/c-parser.c:9198 -#: cp/parser.c:22998 cp/parser.c:24001 +#: cp/parser.c:23002 cp/parser.c:24005 #, gcc-internal-format msgid "expected %<:%>" msgstr "" -#: c/c-parser.c:4831 cp/parser.c:22892 +#: c/c-parser.c:4831 cp/parser.c:22896 #, gcc-internal-format msgid "expected %<while%>" msgstr "" @@ -3880,34 +3881,34 @@ msgstr "" msgid "expected %<.%>" msgstr "" -#: c/c-parser.c:7210 c/c-parser.c:7242 c/c-parser.c:7482 cp/parser.c:24564 -#: cp/parser.c:24638 +#: c/c-parser.c:7210 c/c-parser.c:7242 c/c-parser.c:7482 cp/parser.c:24568 +#: cp/parser.c:24642 #, gcc-internal-format msgid "expected %<@end%>" msgstr "" -#: c/c-parser.c:7899 cp/parser.c:22983 +#: c/c-parser.c:7899 cp/parser.c:22987 #, gcc-internal-format msgid "expected %<>%>" msgstr "" -#: c/c-parser.c:9296 cp/parser.c:23007 +#: c/c-parser.c:9296 cp/parser.c:23011 #, gcc-internal-format msgid "expected %<,%> or %<)%>" msgstr "" #: c/c-parser.c:9549 c/c-parser.c:9580 c/c-parser.c:9816 c/c-parser.c:9968 -#: c/c-parser.c:3968 cp/parser.c:22986 +#: c/c-parser.c:3968 cp/parser.c:22990 #, gcc-internal-format msgid "expected %<=%>" msgstr "" -#: c/c-parser.c:10329 c/c-parser.c:10319 cp/parser.c:27421 +#: c/c-parser.c:10329 c/c-parser.c:10319 cp/parser.c:27425 #, gcc-internal-format msgid "expected %<#pragma omp section%> or %<}%>" msgstr "" -#: c/c-parser.c:10666 cp/parser.c:22971 +#: c/c-parser.c:10666 cp/parser.c:22975 #, gcc-internal-format msgid "expected %<[%>" msgstr "" @@ -3916,11 +3917,11 @@ msgstr "" msgid "(anonymous)" msgstr "" -#: cp/call.c:8680 +#: cp/call.c:8698 msgid "candidate 1:" msgstr "" -#: cp/call.c:8681 +#: cp/call.c:8699 msgid "candidate 2:" msgstr "" @@ -3928,7 +3929,7 @@ msgstr "" msgid "<unnamed>" msgstr "" -#: cp/cxx-pretty-print.c:2149 +#: cp/cxx-pretty-print.c:2153 msgid "template-parameter-" msgstr "" @@ -4008,7 +4009,7 @@ msgstr "" msgid "<declaration error>" msgstr "" -#: cp/error.c:1445 cp/error.c:2855 +#: cp/error.c:1445 cp/error.c:2859 msgid "with" msgstr "" @@ -4030,111 +4031,115 @@ msgstr "" msgid "<unparsed>" msgstr "" -#: cp/error.c:2504 +#: cp/error.c:2498 +msgid "<lambda>" +msgstr "" + +#: cp/error.c:2508 msgid "<expression error>" msgstr "" -#: cp/error.c:2518 +#: cp/error.c:2522 msgid "<unknown operator>" msgstr "" -#: cp/error.c:2807 +#: cp/error.c:2811 msgid "{unknown}" msgstr "" -#: cp/error.c:2922 +#: cp/error.c:2926 msgid "At global scope:" msgstr "" -#: cp/error.c:3028 +#: cp/error.c:3032 #, c-format msgid "In static member function %qs" msgstr "" -#: cp/error.c:3030 +#: cp/error.c:3034 #, c-format msgid "In copy constructor %qs" msgstr "" -#: cp/error.c:3032 +#: cp/error.c:3036 #, c-format msgid "In constructor %qs" msgstr "" -#: cp/error.c:3034 +#: cp/error.c:3038 #, c-format msgid "In destructor %qs" msgstr "" -#: cp/error.c:3036 +#: cp/error.c:3040 msgid "In lambda function" msgstr "" -#: cp/error.c:3056 +#: cp/error.c:3060 #, c-format msgid "%s: In substitution of %qS:\n" msgstr "" -#: cp/error.c:3057 +#: cp/error.c:3061 msgid "%s: In instantiation of %q#D:\n" msgstr "" -#: cp/error.c:3080 +#: cp/error.c:3084 #, c-format msgid "%s:%d:%d: " msgstr "" -#: cp/error.c:3083 +#: cp/error.c:3087 #, c-format msgid "%s:%d: " msgstr "" -#: cp/error.c:3091 +#: cp/error.c:3095 #, c-format msgid "recursively required by substitution of %qS\n" msgstr "" -#: cp/error.c:3092 +#: cp/error.c:3096 #, c-format msgid "required by substitution of %qS\n" msgstr "" -#: cp/error.c:3097 +#: cp/error.c:3101 msgid "recursively required from %q#D\n" msgstr "" -#: cp/error.c:3098 +#: cp/error.c:3102 msgid "required from %q#D\n" msgstr "" -#: cp/error.c:3105 +#: cp/error.c:3109 msgid "recursively required from here" msgstr "" -#: cp/error.c:3106 +#: cp/error.c:3110 msgid "required from here" msgstr "" -#: cp/error.c:3158 +#: cp/error.c:3162 #, c-format msgid "" "%s:%d:%d: [ skipping %d instantiation contexts, use -ftemplate-backtrace-" "limit=0 to disable ]\n" msgstr "" -#: cp/error.c:3163 +#: cp/error.c:3167 #, c-format msgid "" "%s:%d: [ skipping %d instantiation contexts, use -ftemplate-backtrace-" "limit=0 to disable ]\n" msgstr "" -#: cp/error.c:3227 +#: cp/error.c:3231 #, c-format msgid "%s:%d:%d: in constexpr expansion of %qs" msgstr "" -#: cp/error.c:3231 +#: cp/error.c:3235 #, c-format msgid "%s:%d: in constexpr expansion of %qs" msgstr "" @@ -4143,7 +4148,7 @@ msgstr "" msgid "candidates are:" msgstr "" -#: cp/pt.c:17926 cp/call.c:3290 +#: cp/pt.c:17922 cp/call.c:3290 #, gcc-internal-format msgid "candidate is:" msgid_plural "candidates are:" @@ -4668,14 +4673,14 @@ msgstr "" msgid "Integer overflow when calculating the amount of memory to allocate" msgstr "" -#: fortran/trans-decl.c:4842 +#: fortran/trans-decl.c:4844 #, c-format msgid "" "Actual string length does not match the declared one for dummy argument " "'%s' (%ld/%ld)" msgstr "" -#: fortran/trans-decl.c:4850 +#: fortran/trans-decl.c:4852 #, c-format msgid "" "Actual string length is shorter than the declared one for dummy argument " @@ -4692,12 +4697,12 @@ msgstr "" msgid "Unequal character lengths (%ld/%ld) in %s" msgstr "" -#: fortran/trans-intrinsic.c:6157 +#: fortran/trans-intrinsic.c:6156 #, c-format msgid "Argument NCOPIES of REPEAT intrinsic is negative (its value is %ld)" msgstr "" -#: fortran/trans-intrinsic.c:6189 +#: fortran/trans-intrinsic.c:6188 msgid "Argument NCOPIES of REPEAT intrinsic is too large" msgstr "" @@ -4922,7 +4927,7 @@ msgid "" "objc-cpp-output is deprecated; please use objective-c-cpp-output instead" msgstr "" -#: java/jvspec.c:79 ada/gcc-interface/lang-specs.h:33 gcc.c:844 +#: java/jvspec.c:79 ada/gcc-interface/lang-specs.h:33 gcc.c:845 msgid "-pg and -fomit-frame-pointer are incompatible" msgstr "" @@ -4983,7 +4988,7 @@ msgstr "" msgid "consider using '-pg' instead of '-p' with gprof(1)" msgstr "" -#: config/sh/sh.h:360 config/sh/sh.h:363 +#: config/sh/sh.h:363 config/sh/sh.h:366 msgid "SH2a does not support little-endian" msgstr "" @@ -5048,7 +5053,7 @@ msgid "the -shared option is not currently supported for VAX ELF" msgstr "" #: config/i386/mingw-w64.h:82 config/i386/mingw32.h:115 -#: config/i386/cygwin.h:113 +#: config/i386/cygwin.h:109 msgid "shared and mdll are not compatible" msgstr "" @@ -5088,23 +5093,23 @@ msgstr "" msgid "profiling not supported with -mg" msgstr "" -#: gcc.c:704 +#: gcc.c:705 msgid "-fuse-linker-plugin is not supported in this configuration" msgstr "" -#: gcc.c:718 +#: gcc.c:719 msgid "cannot specify -static with -fsanitize=address" msgstr "" -#: gcc.c:720 +#: gcc.c:721 msgid "-fsanitize=thread linking must be done with -pie or -shared" msgstr "" -#: gcc.c:1012 +#: gcc.c:1013 msgid "GNU C no longer supports -traditional without -E" msgstr "" -#: gcc.c:1021 +#: gcc.c:1022 msgid "-E or -x required when input is from standard input" msgstr "" @@ -5158,7 +5163,7 @@ msgstr "" msgid "Warn about most implicit conversions" msgstr "" -#: fortran/lang.opt:234 common.opt:542 +#: fortran/lang.opt:234 common.opt:546 msgid "Print extra (possibly unwanted) warnings" msgstr "" @@ -5308,9 +5313,9 @@ msgstr "" msgid "Allow dollar signs in entity names" msgstr "" -#: fortran/lang.opt:394 config/alpha/alpha.opt:31 common.opt:656 -#: common.opt:830 common.opt:834 common.opt:838 common.opt:842 common.opt:1227 -#: common.opt:1360 common.opt:1364 +#: fortran/lang.opt:394 config/alpha/alpha.opt:31 common.opt:660 +#: common.opt:834 common.opt:838 common.opt:842 common.opt:846 common.opt:1231 +#: common.opt:1364 common.opt:1368 msgid "Does nothing. Preserved for backward compatibility." msgstr "" @@ -5553,7 +5558,7 @@ msgstr "" #: c-family/c.opt:70 c-family/c.opt:73 c-family/c.opt:76 c-family/c.opt:79 #: c-family/c.opt:175 c-family/c.opt:178 c-family/c.opt:216 c-family/c.opt:220 #: c-family/c.opt:232 c-family/c.opt:1253 c-family/c.opt:1261 -#: config/darwin.opt:53 common.opt:300 common.opt:303 common.opt:2399 +#: config/darwin.opt:53 common.opt:300 common.opt:303 common.opt:2403 #, c-format msgid "missing filename after %qs" msgstr "" @@ -6207,9 +6212,9 @@ msgid "Allow the arguments of the '?' operator to have different types" msgstr "" #: c-family/c.opt:856 c-family/c.opt:876 c-family/c.opt:1074 -#: config/sh/sh.opt:209 common.opt:949 common.opt:1135 common.opt:1439 -#: common.opt:1713 common.opt:1749 common.opt:1834 common.opt:1838 -#: common.opt:1914 common.opt:1996 common.opt:2020 common.opt:2108 +#: config/sh/sh.opt:213 common.opt:953 common.opt:1139 common.opt:1443 +#: common.opt:1717 common.opt:1753 common.opt:1838 common.opt:1842 +#: common.opt:1918 common.opt:2000 common.opt:2024 common.opt:2112 msgid "Does nothing. Preserved for backward compatibility." msgstr "" @@ -7432,7 +7437,7 @@ msgid "Enable earlier placing stop bits for better scheduling" msgstr "" #: config/ia64/ia64.opt:114 config/spu/spu.opt:72 config/pa/pa.opt:58 -#: config/sh/sh.opt:261 +#: config/sh/sh.opt:265 msgid "Specify range of registers to make fixed" msgstr "" @@ -7928,7 +7933,7 @@ msgstr "" msgid "Use 64-bit long double" msgstr "" -#: config/i386/i386.opt:98 config/sh/sh.opt:205 +#: config/i386/i386.opt:98 config/sh/sh.opt:209 msgid "Reserve space for outgoing arguments in the function prologue" msgstr "" @@ -8691,6 +8696,10 @@ msgid "" "absence of SPH can be deduced from -mmcu=MCU." msgstr "" +#: config/avr/avr.opt:80 +msgid "Warn if the address space of an address is change." +msgstr "" + #: config/m32r/m32r.opt:34 msgid "Compile for the m32rx" msgstr "" @@ -9771,64 +9780,68 @@ msgid "Use the soft multiply emulation (default)" msgstr "" #: config/microblaze/microblaze.opt:72 -msgid "Use the software emulation for divides (default)" +msgid "Use reorder instructions (swap and byte reversed load/store) (default)" msgstr "" #: config/microblaze/microblaze.opt:76 -msgid "Use the hardware barrel shifter instead of emulation" +msgid "Use the software emulation for divides (default)" msgstr "" #: config/microblaze/microblaze.opt:80 +msgid "Use the hardware barrel shifter instead of emulation" +msgstr "" + +#: config/microblaze/microblaze.opt:84 msgid "Use pattern compare instructions" msgstr "" -#: config/microblaze/microblaze.opt:83 +#: config/microblaze/microblaze.opt:87 #, c-format msgid "%qs is deprecated; use -fstack-check" msgstr "" -#: config/microblaze/microblaze.opt:84 +#: config/microblaze/microblaze.opt:88 msgid "Check for stack overflow at runtime" msgstr "" -#: config/microblaze/microblaze.opt:88 config/iq2000/iq2000.opt:65 +#: config/microblaze/microblaze.opt:92 config/iq2000/iq2000.opt:65 msgid "Use GP relative sdata/sbss sections" msgstr "" -#: config/microblaze/microblaze.opt:91 +#: config/microblaze/microblaze.opt:95 #, c-format msgid "%qs is deprecated; use -fno-zero-initialized-in-bss" msgstr "" -#: config/microblaze/microblaze.opt:92 +#: config/microblaze/microblaze.opt:96 msgid "Clear the BSS to zero and place zero initialized in BSS" msgstr "" -#: config/microblaze/microblaze.opt:96 +#: config/microblaze/microblaze.opt:100 msgid "Use multiply high instructions for high part of 32x32 multiply" msgstr "" -#: config/microblaze/microblaze.opt:100 +#: config/microblaze/microblaze.opt:104 msgid "Use hardware floating point conversion instructions" msgstr "" -#: config/microblaze/microblaze.opt:104 +#: config/microblaze/microblaze.opt:108 msgid "Use hardware floating point square root instruction" msgstr "" -#: config/microblaze/microblaze.opt:108 +#: config/microblaze/microblaze.opt:112 msgid "Description for mxl-mode-executable" msgstr "" -#: config/microblaze/microblaze.opt:112 +#: config/microblaze/microblaze.opt:116 msgid "Description for mxl-mode-xmdstub" msgstr "" -#: config/microblaze/microblaze.opt:116 +#: config/microblaze/microblaze.opt:120 msgid "Description for mxl-mode-bootstrap" msgstr "" -#: config/microblaze/microblaze.opt:120 +#: config/microblaze/microblaze.opt:124 msgid "Description for mxl-mode-novectors" msgstr "" @@ -10178,303 +10191,303 @@ msgstr "" msgid "Runtime name." msgstr "" -#: config/sh/sh.opt:44 +#: config/sh/sh.opt:48 msgid "Generate SH1 code" msgstr "" -#: config/sh/sh.opt:48 +#: config/sh/sh.opt:52 msgid "Generate SH2 code" msgstr "" -#: config/sh/sh.opt:52 +#: config/sh/sh.opt:56 msgid "Generate default double-precision SH2a-FPU code" msgstr "" -#: config/sh/sh.opt:56 +#: config/sh/sh.opt:60 msgid "Generate SH2a FPU-less code" msgstr "" -#: config/sh/sh.opt:60 +#: config/sh/sh.opt:64 msgid "Generate default single-precision SH2a-FPU code" msgstr "" -#: config/sh/sh.opt:64 +#: config/sh/sh.opt:68 msgid "Generate only single-precision SH2a-FPU code" msgstr "" -#: config/sh/sh.opt:68 +#: config/sh/sh.opt:72 msgid "Generate SH2e code" msgstr "" -#: config/sh/sh.opt:72 +#: config/sh/sh.opt:76 msgid "Generate SH3 code" msgstr "" -#: config/sh/sh.opt:76 +#: config/sh/sh.opt:80 msgid "Generate SH3e code" msgstr "" -#: config/sh/sh.opt:80 +#: config/sh/sh.opt:84 msgid "Generate SH4 code" msgstr "" -#: config/sh/sh.opt:84 +#: config/sh/sh.opt:88 msgid "Generate SH4-100 code" msgstr "" -#: config/sh/sh.opt:88 +#: config/sh/sh.opt:92 msgid "Generate SH4-200 code" msgstr "" -#: config/sh/sh.opt:94 +#: config/sh/sh.opt:98 msgid "Generate SH4-300 code" msgstr "" -#: config/sh/sh.opt:98 +#: config/sh/sh.opt:102 msgid "Generate SH4 FPU-less code" msgstr "" -#: config/sh/sh.opt:102 +#: config/sh/sh.opt:106 msgid "Generate SH4-100 FPU-less code" msgstr "" -#: config/sh/sh.opt:106 +#: config/sh/sh.opt:110 msgid "Generate SH4-200 FPU-less code" msgstr "" -#: config/sh/sh.opt:110 +#: config/sh/sh.opt:114 msgid "Generate SH4-300 FPU-less code" msgstr "" -#: config/sh/sh.opt:114 +#: config/sh/sh.opt:118 msgid "Generate code for SH4 340 series (MMU/FPU-less)" msgstr "" -#: config/sh/sh.opt:119 +#: config/sh/sh.opt:123 msgid "Generate code for SH4 400 series (MMU/FPU-less)" msgstr "" -#: config/sh/sh.opt:124 +#: config/sh/sh.opt:128 msgid "Generate code for SH4 500 series (FPU-less)." msgstr "" -#: config/sh/sh.opt:129 +#: config/sh/sh.opt:133 msgid "Generate default single-precision SH4 code" msgstr "" -#: config/sh/sh.opt:133 +#: config/sh/sh.opt:137 msgid "Generate default single-precision SH4-100 code" msgstr "" -#: config/sh/sh.opt:137 +#: config/sh/sh.opt:141 msgid "Generate default single-precision SH4-200 code" msgstr "" -#: config/sh/sh.opt:141 +#: config/sh/sh.opt:145 msgid "Generate default single-precision SH4-300 code" msgstr "" -#: config/sh/sh.opt:145 +#: config/sh/sh.opt:149 msgid "Generate only single-precision SH4 code" msgstr "" -#: config/sh/sh.opt:149 +#: config/sh/sh.opt:153 msgid "Generate only single-precision SH4-100 code" msgstr "" -#: config/sh/sh.opt:153 +#: config/sh/sh.opt:157 msgid "Generate only single-precision SH4-200 code" msgstr "" -#: config/sh/sh.opt:157 +#: config/sh/sh.opt:161 msgid "Generate only single-precision SH4-300 code" msgstr "" -#: config/sh/sh.opt:161 +#: config/sh/sh.opt:165 msgid "Generate SH4a code" msgstr "" -#: config/sh/sh.opt:165 +#: config/sh/sh.opt:169 msgid "Generate SH4a FPU-less code" msgstr "" -#: config/sh/sh.opt:169 +#: config/sh/sh.opt:173 msgid "Generate default single-precision SH4a code" msgstr "" -#: config/sh/sh.opt:173 +#: config/sh/sh.opt:177 msgid "Generate only single-precision SH4a code" msgstr "" -#: config/sh/sh.opt:177 +#: config/sh/sh.opt:181 msgid "Generate SH4al-dsp code" msgstr "" -#: config/sh/sh.opt:181 +#: config/sh/sh.opt:185 msgid "Generate 32-bit SHmedia code" msgstr "" -#: config/sh/sh.opt:185 +#: config/sh/sh.opt:189 msgid "Generate 32-bit FPU-less SHmedia code" msgstr "" -#: config/sh/sh.opt:189 +#: config/sh/sh.opt:193 msgid "Generate 64-bit SHmedia code" msgstr "" -#: config/sh/sh.opt:193 +#: config/sh/sh.opt:197 msgid "Generate 64-bit FPU-less SHmedia code" msgstr "" -#: config/sh/sh.opt:197 +#: config/sh/sh.opt:201 msgid "Generate SHcompact code" msgstr "" -#: config/sh/sh.opt:201 +#: config/sh/sh.opt:205 msgid "Generate FPU-less SHcompact code" msgstr "" -#: config/sh/sh.opt:213 +#: config/sh/sh.opt:217 msgid "Generate code in big endian mode" msgstr "" -#: config/sh/sh.opt:217 +#: config/sh/sh.opt:221 msgid "Generate 32-bit offsets in switch tables" msgstr "" -#: config/sh/sh.opt:221 +#: config/sh/sh.opt:225 msgid "Generate bit instructions" msgstr "" -#: config/sh/sh.opt:225 +#: config/sh/sh.opt:229 msgid "Cost to assume for a branch insn" msgstr "" -#: config/sh/sh.opt:229 +#: config/sh/sh.opt:233 msgid "Assume that zero displacement conditional branches are fast" msgstr "" -#: config/sh/sh.opt:233 +#: config/sh/sh.opt:237 msgid "Enable cbranchdi4 pattern" msgstr "" -#: config/sh/sh.opt:237 +#: config/sh/sh.opt:241 msgid "Emit cmpeqdi_t pattern even when -mcbranchdi is in effect." msgstr "" -#: config/sh/sh.opt:241 +#: config/sh/sh.opt:245 msgid "Enable SH5 cut2 workaround" msgstr "" -#: config/sh/sh.opt:245 +#: config/sh/sh.opt:249 msgid "Align doubles at 64-bit boundaries" msgstr "" -#: config/sh/sh.opt:249 +#: config/sh/sh.opt:253 msgid "" "Division strategy, one of: call, call2, fp, inv, inv:minlat, inv20u, inv20l, " "inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table" msgstr "" -#: config/sh/sh.opt:253 +#: config/sh/sh.opt:257 msgid "Specify name for 32 bit signed division function" msgstr "" -#: config/sh/sh.opt:257 +#: config/sh/sh.opt:261 msgid "" "Enable the use of 64-bit floating point registers in fmov instructions. See " "-mdalign if 64-bit alignment is required." msgstr "" -#: config/sh/sh.opt:265 +#: config/sh/sh.opt:269 msgid "Cost to assume for gettr insn" msgstr "" -#: config/sh/sh.opt:269 config/sh/sh.opt:319 +#: config/sh/sh.opt:273 config/sh/sh.opt:323 msgid "Follow Renesas (formerly Hitachi) / SuperH calling conventions" msgstr "" -#: config/sh/sh.opt:273 +#: config/sh/sh.opt:277 msgid "Increase the IEEE compliance for floating-point comparisons" msgstr "" -#: config/sh/sh.opt:277 +#: config/sh/sh.opt:281 msgid "Enable the use of the indexed addressing mode for SHmedia32/SHcompact" msgstr "" -#: config/sh/sh.opt:281 +#: config/sh/sh.opt:285 msgid "" "inline code to invalidate instruction cache entries after setting up nested " "function trampolines" msgstr "" -#: config/sh/sh.opt:285 +#: config/sh/sh.opt:289 msgid "Assume symbols might be invalid" msgstr "" -#: config/sh/sh.opt:289 +#: config/sh/sh.opt:293 msgid "Annotate assembler instructions with estimated addresses" msgstr "" -#: config/sh/sh.opt:293 +#: config/sh/sh.opt:297 msgid "Generate code in little endian mode" msgstr "" -#: config/sh/sh.opt:297 +#: config/sh/sh.opt:301 msgid "Mark MAC register as call-clobbered" msgstr "" -#: config/sh/sh.opt:303 +#: config/sh/sh.opt:307 msgid "Make structs a multiple of 4 bytes (warning: ABI altered)" msgstr "" -#: config/sh/sh.opt:307 +#: config/sh/sh.opt:311 msgid "Emit function-calls using global offset table when generating PIC" msgstr "" -#: config/sh/sh.opt:311 +#: config/sh/sh.opt:315 msgid "Assume pt* instructions won't trap" msgstr "" -#: config/sh/sh.opt:315 +#: config/sh/sh.opt:319 msgid "Shorten address references during linking" msgstr "" -#: config/sh/sh.opt:323 +#: config/sh/sh.opt:327 msgid "Deprecated. Use -matomic= instead to select the atomic model" msgstr "" -#: config/sh/sh.opt:327 +#: config/sh/sh.opt:331 msgid "Specify the model for atomic operations" msgstr "" -#: config/sh/sh.opt:331 +#: config/sh/sh.opt:335 msgid "Use tas.b instruction for __atomic_test_and_set" msgstr "" -#: config/sh/sh.opt:335 +#: config/sh/sh.opt:339 msgid "Deprecated. Use -Os instead" msgstr "" -#: config/sh/sh.opt:339 +#: config/sh/sh.opt:343 msgid "Cost to assume for a multiply insn" msgstr "" -#: config/sh/sh.opt:343 +#: config/sh/sh.opt:347 msgid "" "Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate " "if the inline code would not work in user mode." msgstr "" -#: config/sh/sh.opt:349 +#: config/sh/sh.opt:353 msgid "Pretend a branch-around-a-move is a conditional move." msgstr "" -#: config/sh/sh.opt:353 +#: config/sh/sh.opt:357 msgid "Enable the use of the fsca instruction" msgstr "" -#: config/sh/sh.opt:357 +#: config/sh/sh.opt:361 msgid "Enable the use of the fsrra instruction" msgstr "" @@ -11079,1631 +11092,1636 @@ msgid "Warn about returning structures, unions or arrays" msgstr "" #: common.opt:510 -msgid "Warn if an array is accessed out of bounds" +msgid "" +"Warn if a loop with constant number of iterations triggers undefined behavior" msgstr "" #: common.opt:514 -msgid "Warn about inappropriate attribute usage" +msgid "Warn if an array is accessed out of bounds" msgstr "" #: common.opt:518 -msgid "Warn about pointer casts which increase alignment" +msgid "Warn about inappropriate attribute usage" msgstr "" #: common.opt:522 -msgid "Warn when a #warning directive is encountered" +msgid "Warn about pointer casts which increase alignment" msgstr "" #: common.opt:526 -msgid "Warn about uses of __attribute__((deprecated)) declarations" +msgid "Warn when a #warning directive is encountered" msgstr "" #: common.opt:530 -msgid "Warn when an optimization pass is disabled" +msgid "Warn about uses of __attribute__((deprecated)) declarations" msgstr "" #: common.opt:534 -msgid "Treat all warnings as errors" +msgid "Warn when an optimization pass is disabled" msgstr "" #: common.opt:538 +msgid "Treat all warnings as errors" +msgstr "" + +#: common.opt:542 msgid "Treat specified warning as error" msgstr "" -#: common.opt:546 +#: common.opt:550 msgid "Exit on the first error occurred" msgstr "" -#: common.opt:550 +#: common.opt:554 msgid "" "-Wframe-larger-than=<number>\tWarn if a function's stack frame requires more " "than <number> bytes" msgstr "" -#: common.opt:554 +#: common.opt:558 msgid "Warn when attempting to free a non-heap object" msgstr "" -#: common.opt:558 +#: common.opt:562 msgid "Warn when an inlined function cannot be inlined" msgstr "" -#: common.opt:562 +#: common.opt:566 msgid "" "Warn when an atomic memory model parameter is known to be outside the valid " "range." msgstr "" -#: common.opt:569 +#: common.opt:573 msgid "-Wlarger-than=<number>\tWarn if an object is larger than <number> bytes" msgstr "" -#: common.opt:573 +#: common.opt:577 msgid "Warn if the loop cannot be optimized due to nontrivial assumptions." msgstr "" -#: common.opt:580 +#: common.opt:584 msgid "Warn about overflow in arithmetic expressions" msgstr "" -#: common.opt:584 +#: common.opt:588 msgid "Warn when the packed attribute has no effect on struct layout" msgstr "" -#: common.opt:588 +#: common.opt:592 msgid "Warn when padding is required to align structure members" msgstr "" -#: common.opt:592 +#: common.opt:596 msgid "Issue warnings needed for strict compliance to the standard" msgstr "" -#: common.opt:596 +#: common.opt:600 msgid "Warn when one local variable shadows another" msgstr "" -#: common.opt:600 +#: common.opt:604 msgid "Warn when not issuing stack smashing protection for some reason" msgstr "" -#: common.opt:604 +#: common.opt:608 msgid "Warn if stack usage might be larger than specified amount" msgstr "" -#: common.opt:608 common.opt:612 +#: common.opt:612 common.opt:616 msgid "Warn about code which might break strict aliasing rules" msgstr "" -#: common.opt:616 common.opt:620 +#: common.opt:620 common.opt:624 msgid "Warn about optimizations that assume that signed overflow is undefined" msgstr "" -#: common.opt:624 +#: common.opt:628 msgid "" "Warn about functions which might be candidates for __attribute__((const))" msgstr "" -#: common.opt:628 +#: common.opt:632 msgid "" "Warn about functions which might be candidates for __attribute__((pure))" msgstr "" -#: common.opt:632 +#: common.opt:636 msgid "" "Warn about functions which might be candidates for __attribute__((noreturn))" msgstr "" -#: common.opt:636 +#: common.opt:640 msgid "Do not suppress warnings from system headers" msgstr "" -#: common.opt:640 +#: common.opt:644 msgid "Warn whenever a trampoline is generated" msgstr "" -#: common.opt:644 +#: common.opt:648 msgid "" "Warn if a comparison is always true or always false due to the limited range " "of the data type" msgstr "" -#: common.opt:648 +#: common.opt:652 msgid "Warn about uninitialized automatic variables" msgstr "" -#: common.opt:652 +#: common.opt:656 msgid "Warn about maybe uninitialized automatic variables" msgstr "" -#: common.opt:660 +#: common.opt:664 msgid "Enable all -Wunused- warnings" msgstr "" -#: common.opt:664 +#: common.opt:668 msgid "Warn when a function parameter is only set, otherwise unused" msgstr "" -#: common.opt:668 +#: common.opt:672 msgid "Warn when a variable is only set, otherwise unused" msgstr "" -#: common.opt:672 +#: common.opt:676 msgid "Warn when a function is unused" msgstr "" -#: common.opt:676 +#: common.opt:680 msgid "Warn when a label is unused" msgstr "" -#: common.opt:680 +#: common.opt:684 msgid "Warn when a function parameter is unused" msgstr "" -#: common.opt:684 +#: common.opt:688 msgid "Warn when an expression value is unused" msgstr "" -#: common.opt:688 +#: common.opt:692 msgid "Warn when a variable is unused" msgstr "" -#: common.opt:692 +#: common.opt:696 msgid "Warn in case profiles in -fprofile-use do not match" msgstr "" -#: common.opt:696 +#: common.opt:700 msgid "Warn when a vector operation is compiled outside the SIMD" msgstr "" -#: common.opt:712 +#: common.opt:716 msgid "-aux-info <file>\tEmit declaration information into <file>" msgstr "" -#: common.opt:731 +#: common.opt:735 msgid "-d<letters>\tEnable dumps from specific passes of the compiler" msgstr "" -#: common.opt:735 +#: common.opt:739 msgid "-dumpbase <file>\tSet the file basename to be used for dumps" msgstr "" -#: common.opt:739 +#: common.opt:743 msgid "-dumpdir <dir>\tSet the directory name to be used for dumps" msgstr "" -#: common.opt:798 +#: common.opt:802 msgid "Aggressively optimize loops using language constraints" msgstr "" -#: common.opt:802 +#: common.opt:806 msgid "Align the start of functions" msgstr "" -#: common.opt:809 +#: common.opt:813 msgid "Align labels which are only reached by jumping" msgstr "" -#: common.opt:816 +#: common.opt:820 msgid "Align all labels" msgstr "" -#: common.opt:823 +#: common.opt:827 msgid "Align the start of loops" msgstr "" -#: common.opt:846 +#: common.opt:850 msgid "Enable AddressSanitizer, a memory error detector" msgstr "" -#: common.opt:850 +#: common.opt:854 msgid "Enable ThreadSanitizer, a data race detector" msgstr "" -#: common.opt:854 +#: common.opt:858 msgid "Generate unwind tables that are exact at each instruction boundary" msgstr "" -#: common.opt:858 +#: common.opt:862 msgid "Generate auto-inc/dec instructions" msgstr "" -#: common.opt:866 +#: common.opt:870 msgid "Generate code to check bounds before indexing arrays" msgstr "" -#: common.opt:870 +#: common.opt:874 msgid "Replace add, compare, branch with branch on count register" msgstr "" -#: common.opt:874 +#: common.opt:878 msgid "Use profiling information for branch probabilities" msgstr "" -#: common.opt:878 +#: common.opt:882 msgid "" "Perform branch target load optimization before prologue / epilogue threading" msgstr "" -#: common.opt:882 +#: common.opt:886 msgid "" "Perform branch target load optimization after prologue / epilogue threading" msgstr "" -#: common.opt:886 +#: common.opt:890 msgid "" "Restrict target load migration not to re-use registers in any basic block" msgstr "" -#: common.opt:890 +#: common.opt:894 msgid "" "-fcall-saved-<register>\tMark <register> as being preserved across functions" msgstr "" -#: common.opt:894 +#: common.opt:898 msgid "" "-fcall-used-<register>\tMark <register> as being corrupted by function calls" msgstr "" -#: common.opt:901 +#: common.opt:905 msgid "Save registers around function calls" msgstr "" -#: common.opt:905 +#: common.opt:909 msgid "Compare the results of several data dependence analyzers." msgstr "" -#: common.opt:909 +#: common.opt:913 msgid "" "Looks for opportunities to reduce stack adjustments and stack references." msgstr "" -#: common.opt:913 +#: common.opt:917 msgid "Do not put uninitialized globals in the common section" msgstr "" -#: common.opt:921 +#: common.opt:925 msgid "" "-fcompare-debug[=<opts>]\tCompile with and without e.g. -gtoggle, and " "compare the final-insns dump" msgstr "" -#: common.opt:925 +#: common.opt:929 msgid "Run only the second compilation of -fcompare-debug" msgstr "" -#: common.opt:929 +#: common.opt:933 msgid "Perform comparison elimination after register allocation has finished" msgstr "" -#: common.opt:933 +#: common.opt:937 msgid "Do not perform optimizations increasing noticeably stack usage" msgstr "" -#: common.opt:937 +#: common.opt:941 msgid "Perform a register copy-propagation optimization pass" msgstr "" -#: common.opt:941 +#: common.opt:945 msgid "Perform cross-jumping optimization" msgstr "" -#: common.opt:945 +#: common.opt:949 msgid "When running CSE, follow jumps to their targets" msgstr "" -#: common.opt:953 +#: common.opt:957 msgid "Omit range reduction step when performing complex division" msgstr "" -#: common.opt:957 +#: common.opt:961 msgid "Complex multiplication and division follow Fortran rules" msgstr "" -#: common.opt:961 +#: common.opt:965 msgid "Place data items into their own section" msgstr "" -#: common.opt:965 +#: common.opt:969 msgid "List all available debugging counters with their limits and counts." msgstr "" -#: common.opt:969 +#: common.opt:973 msgid "" "-fdbg-cnt=<counter>:<limit>[,<counter>:<limit>,...]\tSet the debug counter " "limit. " msgstr "" -#: common.opt:973 +#: common.opt:977 msgid "Map one directory name to another in debug information" msgstr "" -#: common.opt:977 +#: common.opt:981 msgid "Output .debug_types section when using DWARF v4 debuginfo." msgstr "" -#: common.opt:983 +#: common.opt:987 msgid "Defer popping functions args from stack until later" msgstr "" -#: common.opt:987 +#: common.opt:991 msgid "Attempt to fill delay slots of branch instructions" msgstr "" -#: common.opt:991 +#: common.opt:995 msgid "Delete dead instructions that may throw exceptions" msgstr "" -#: common.opt:995 +#: common.opt:999 msgid "Delete useless null pointer checks" msgstr "" -#: common.opt:999 +#: common.opt:1003 msgid "Try to convert virtual calls to direct ones." msgstr "" -#: common.opt:1003 +#: common.opt:1007 msgid "" "-fdiagnostics-show-location=[once|every-line]\tHow often to emit source " "location at the beginning of line-wrapped diagnostics" msgstr "" -#: common.opt:1020 +#: common.opt:1024 msgid "Show the source line with a caret indicating the column" msgstr "" -#: common.opt:1024 +#: common.opt:1028 msgid "" "Amend appropriate diagnostic messages with the command line option that " "controls them" msgstr "" -#: common.opt:1028 +#: common.opt:1032 msgid "" "-fdisable-[tree|rtl|ipa]-<pass>=range1+range2 disables an optimization pass" msgstr "" -#: common.opt:1032 +#: common.opt:1036 msgid "" "-fenable-[tree|rtl|ipa]-<pass>=range1+range2 enables an optimization pass" msgstr "" -#: common.opt:1036 +#: common.opt:1040 msgid "-fdump-<type>\tDump various compiler internals to a file" msgstr "" -#: common.opt:1043 +#: common.opt:1047 msgid "" "-fdump-final-insns=filename\tDump to filename the insns at the end of " "translation" msgstr "" -#: common.opt:1047 +#: common.opt:1051 msgid "-fdump-go-spec=filename\tWrite all declarations to file as Go code" msgstr "" -#: common.opt:1051 +#: common.opt:1055 msgid "Suppress output of addresses in debugging dumps" msgstr "" -#: common.opt:1055 +#: common.opt:1059 msgid "Dump optimization passes" msgstr "" -#: common.opt:1059 +#: common.opt:1063 msgid "" "Suppress output of instruction numbers, line number notes and addresses in " "debugging dumps" msgstr "" -#: common.opt:1063 +#: common.opt:1067 msgid "Suppress output of previous and next insn numbers in debugging dumps" msgstr "" -#: common.opt:1067 +#: common.opt:1071 msgid "Enable CFI tables via GAS assembler directives." msgstr "" -#: common.opt:1071 +#: common.opt:1075 msgid "Perform early inlining" msgstr "" -#: common.opt:1075 +#: common.opt:1079 msgid "Perform DWARF2 duplicate elimination" msgstr "" -#: common.opt:1079 +#: common.opt:1083 msgid "Perform interprocedural reduction of aggregates" msgstr "" -#: common.opt:1083 common.opt:1087 +#: common.opt:1087 common.opt:1091 msgid "Perform unused type elimination in debug info" msgstr "" -#: common.opt:1091 +#: common.opt:1095 msgid "Do not suppress C++ class debug information." msgstr "" -#: common.opt:1095 +#: common.opt:1099 msgid "Enable exception handling" msgstr "" -#: common.opt:1099 +#: common.opt:1103 msgid "Perform a number of minor, expensive optimizations" msgstr "" -#: common.opt:1103 +#: common.opt:1107 msgid "" "-fexcess-precision=[fast|standard]\tSpecify handling of excess floating-" "point precision" msgstr "" -#: common.opt:1106 +#: common.opt:1110 #, c-format msgid "unknown excess precision style %qs" msgstr "" -#: common.opt:1119 +#: common.opt:1123 msgid "" "Output lto objects containing both the intermediate language and binary " "output." msgstr "" -#: common.opt:1123 +#: common.opt:1127 msgid "Assume no NaNs or infinities are generated" msgstr "" -#: common.opt:1127 +#: common.opt:1131 msgid "" "-ffixed-<register>\tMark <register> as being unavailable to the compiler" msgstr "" -#: common.opt:1131 +#: common.opt:1135 msgid "Don't allocate floats and doubles in extended-precision registers" msgstr "" -#: common.opt:1139 +#: common.opt:1143 msgid "Perform a forward propagation pass on RTL" msgstr "" -#: common.opt:1143 +#: common.opt:1147 msgid "" "-ffp-contract=[off|on|fast] Perform floating-point expression contraction." msgstr "" -#: common.opt:1146 +#: common.opt:1150 #, c-format msgid "unknown floating point contraction style %qs" msgstr "" -#: common.opt:1163 +#: common.opt:1167 msgid "Allow function addresses to be held in registers" msgstr "" -#: common.opt:1167 +#: common.opt:1171 msgid "Place each function into its own section" msgstr "" -#: common.opt:1171 +#: common.opt:1175 msgid "Perform global common subexpression elimination" msgstr "" -#: common.opt:1175 +#: common.opt:1179 msgid "" "Perform enhanced load motion during global common subexpression elimination" msgstr "" -#: common.opt:1179 +#: common.opt:1183 msgid "Perform store motion after global common subexpression elimination" msgstr "" -#: common.opt:1183 +#: common.opt:1187 msgid "" "Perform redundant load after store elimination in global common subexpression" msgstr "" -#: common.opt:1188 +#: common.opt:1192 msgid "" "Perform global common subexpression elimination after register allocation" msgstr "" -#: common.opt:1194 +#: common.opt:1198 msgid "Enable in and out of Graphite representation" msgstr "" -#: common.opt:1198 +#: common.opt:1202 msgid "Enable Graphite Identity transformation" msgstr "" -#: common.opt:1202 +#: common.opt:1206 msgid "Enable hoisting adjacent loads to encourage generating conditional move" msgstr "" -#: common.opt:1207 +#: common.opt:1211 msgid "Mark all loops as parallel" msgstr "" -#: common.opt:1211 +#: common.opt:1215 msgid "Enable Loop Strip Mining transformation" msgstr "" -#: common.opt:1215 +#: common.opt:1219 msgid "Enable Loop Interchange transformation" msgstr "" -#: common.opt:1219 +#: common.opt:1223 msgid "Enable Loop Blocking transformation" msgstr "" -#: common.opt:1223 +#: common.opt:1227 msgid "Enable support for GNU transactional memory" msgstr "" -#: common.opt:1231 +#: common.opt:1235 msgid "Enable the ISL based loop nest optimizer" msgstr "" -#: common.opt:1235 +#: common.opt:1239 msgid "Force bitfield accesses to match their type width" msgstr "" -#: common.opt:1239 +#: common.opt:1243 msgid "Enable guessing of branch probabilities" msgstr "" -#: common.opt:1247 +#: common.opt:1251 msgid "Process #ident directives" msgstr "" -#: common.opt:1251 +#: common.opt:1255 msgid "Perform conversion of conditional jumps to branchless equivalents" msgstr "" -#: common.opt:1255 +#: common.opt:1259 msgid "Perform conversion of conditional jumps to conditional execution" msgstr "" -#: common.opt:1259 +#: common.opt:1263 msgid "" "-fstack-reuse=[all|named_vars|none] Set stack reuse level for local " "variables." msgstr "" -#: common.opt:1262 +#: common.opt:1266 #, c-format msgid "unknown Stack Reuse Level %qs" msgstr "" -#: common.opt:1275 +#: common.opt:1279 msgid "Convert conditional jumps in innermost loops to branchless equivalents" msgstr "" -#: common.opt:1279 +#: common.opt:1283 msgid "Also if-convert conditional jumps containing memory writes" msgstr "" -#: common.opt:1287 +#: common.opt:1291 msgid "Do not generate .size directives" msgstr "" -#: common.opt:1291 +#: common.opt:1295 msgid "Perform indirect inlining" msgstr "" -#: common.opt:1297 +#: common.opt:1301 msgid "" "Enable inlining of function declared \"inline\", disabling disables all " "inlining" msgstr "" -#: common.opt:1301 +#: common.opt:1305 msgid "" "Integrate functions into their callers when code size is known not to grow" msgstr "" -#: common.opt:1305 +#: common.opt:1309 msgid "" "Integrate functions not declared \"inline\" into their callers when " "profitable" msgstr "" -#: common.opt:1309 +#: common.opt:1313 msgid "Integrate functions only required by their single caller" msgstr "" -#: common.opt:1316 +#: common.opt:1320 msgid "" "-finline-limit=<number>\tLimit the size of inlined functions to <number>" msgstr "" -#: common.opt:1320 +#: common.opt:1324 msgid "" "Inline __atomic operations when a lock free instruction sequence is " "available." msgstr "" -#: common.opt:1324 +#: common.opt:1328 msgid "Instrument function entry and exit with profiling calls" msgstr "" -#: common.opt:1328 +#: common.opt:1332 msgid "" "-finstrument-functions-exclude-function-list=name,... Do not instrument " "listed functions" msgstr "" -#: common.opt:1332 +#: common.opt:1336 msgid "" "-finstrument-functions-exclude-file-list=filename,... Do not instrument " "functions listed in files" msgstr "" -#: common.opt:1336 +#: common.opt:1340 msgid "Perform Interprocedural constant propagation" msgstr "" -#: common.opt:1340 +#: common.opt:1344 msgid "Perform cloning to make Interprocedural constant propagation stronger" msgstr "" -#: common.opt:1344 +#: common.opt:1348 msgid "Perform interprocedural profile propagation" msgstr "" -#: common.opt:1348 +#: common.opt:1352 msgid "Perform interprocedural points-to analysis" msgstr "" -#: common.opt:1352 +#: common.opt:1356 msgid "Discover pure and const functions" msgstr "" -#: common.opt:1356 +#: common.opt:1360 msgid "Discover readonly and non addressable static variables" msgstr "" -#: common.opt:1368 +#: common.opt:1372 msgid "-fira-algorithm=[CB|priority] Set the used IRA algorithm" msgstr "" -#: common.opt:1371 +#: common.opt:1375 #, c-format msgid "unknown IRA algorithm %qs" msgstr "" -#: common.opt:1381 +#: common.opt:1385 msgid "-fira-region=[one|all|mixed] Set regions for IRA" msgstr "" -#: common.opt:1384 +#: common.opt:1388 #, c-format msgid "unknown IRA region %qs" msgstr "" -#: common.opt:1397 common.opt:1402 +#: common.opt:1401 common.opt:1406 msgid "Use IRA based register pressure calculation" msgstr "" -#: common.opt:1407 +#: common.opt:1411 msgid "Share slots for saving different hard registers." msgstr "" -#: common.opt:1411 +#: common.opt:1415 msgid "Share stack slots for spilled pseudo-registers." msgstr "" -#: common.opt:1415 +#: common.opt:1419 msgid "-fira-verbose=<number>\tControl IRA's level of diagnostic messages." msgstr "" -#: common.opt:1419 +#: common.opt:1423 msgid "Optimize induction variables on trees" msgstr "" -#: common.opt:1423 +#: common.opt:1427 msgid "Use jump tables for sufficiently large switch statements" msgstr "" -#: common.opt:1427 +#: common.opt:1431 msgid "Generate code for functions even if they are fully inlined" msgstr "" -#: common.opt:1431 +#: common.opt:1435 msgid "Emit static const variables even if they are not used" msgstr "" -#: common.opt:1435 +#: common.opt:1439 msgid "Give external symbols a leading underscore" msgstr "" -#: common.opt:1443 +#: common.opt:1447 msgid "Enable link-time optimization." msgstr "" -#: common.opt:1447 +#: common.opt:1451 msgid "Link-time optimization with number of parallel jobs or jobserver." msgstr "" -#: common.opt:1451 +#: common.opt:1455 msgid "" "Partition symbols and vars at linktime based on object files they originate " "from" msgstr "" -#: common.opt:1455 +#: common.opt:1459 msgid "" "Partition functions and vars at linktime into approximately same sized " "buckets" msgstr "" -#: common.opt:1459 +#: common.opt:1463 msgid "Put every symbol into separate partition" msgstr "" -#: common.opt:1463 +#: common.opt:1467 msgid "Disable partioning and streaming" msgstr "" -#: common.opt:1468 +#: common.opt:1472 msgid "" "-flto-compression-level=<number>\tUse zlib compression level <number> for IL" msgstr "" -#: common.opt:1472 +#: common.opt:1476 msgid "Report various link-time optimization statistics" msgstr "" -#: common.opt:1476 +#: common.opt:1480 msgid "Set errno after built-in math functions" msgstr "" -#: common.opt:1480 +#: common.opt:1484 msgid "-fmax-errors=<number>\tMaximum number of errors to report" msgstr "" -#: common.opt:1484 +#: common.opt:1488 msgid "Report on permanent memory allocation" msgstr "" -#: common.opt:1488 +#: common.opt:1492 msgid "Report on permanent memory allocation in WPA only" msgstr "" -#: common.opt:1495 +#: common.opt:1499 msgid "Attempt to merge identical constants and constant variables" msgstr "" -#: common.opt:1499 +#: common.opt:1503 msgid "Attempt to merge identical constants across compilation units" msgstr "" -#: common.opt:1503 +#: common.opt:1507 msgid "Attempt to merge identical debug strings across compilation units" msgstr "" -#: common.opt:1507 +#: common.opt:1511 msgid "" "-fmessage-length=<number>\tLimit diagnostics to <number> characters per " "line. 0 suppresses line-wrapping" msgstr "" -#: common.opt:1511 +#: common.opt:1515 msgid "Perform SMS based modulo scheduling before the first scheduling pass" msgstr "" -#: common.opt:1515 +#: common.opt:1519 msgid "Perform SMS based modulo scheduling with register moves allowed" msgstr "" -#: common.opt:1519 +#: common.opt:1523 msgid "Move loop invariant computations out of loops" msgstr "" -#: common.opt:1523 +#: common.opt:1527 msgid "Use the RTL dead code elimination pass" msgstr "" -#: common.opt:1527 +#: common.opt:1531 msgid "Use the RTL dead store elimination pass" msgstr "" -#: common.opt:1531 +#: common.opt:1535 msgid "" "Enable/Disable the traditional scheduling in loops that already passed " "modulo scheduling" msgstr "" -#: common.opt:1535 +#: common.opt:1539 msgid "Support synchronous non-call exceptions" msgstr "" -#: common.opt:1539 +#: common.opt:1543 msgid "When possible do not generate stack frames" msgstr "" -#: common.opt:1543 +#: common.opt:1547 msgid "Enable all optimization info dumps on stderr" msgstr "" -#: common.opt:1547 +#: common.opt:1551 msgid "-fopt-info[-<type>=filename]\tDump compiler optimization details" msgstr "" -#: common.opt:1551 +#: common.opt:1555 msgid "Do the full register move optimization pass" msgstr "" -#: common.opt:1555 +#: common.opt:1559 msgid "Optimize sibling and tail recursive calls" msgstr "" -#: common.opt:1559 +#: common.opt:1563 msgid "Perform partial inlining" msgstr "" -#: common.opt:1563 common.opt:1567 +#: common.opt:1567 common.opt:1571 msgid "Report on memory allocation before interprocedural optimization" msgstr "" -#: common.opt:1571 +#: common.opt:1575 msgid "Pack structure members together without holes" msgstr "" -#: common.opt:1575 +#: common.opt:1579 msgid "-fpack-struct=<number>\tSet initial maximum structure member alignment" msgstr "" -#: common.opt:1579 +#: common.opt:1583 msgid "Return small aggregates in memory, not registers" msgstr "" -#: common.opt:1583 +#: common.opt:1587 msgid "Perform loop peeling" msgstr "" -#: common.opt:1587 +#: common.opt:1591 msgid "Enable machine specific peephole optimizations" msgstr "" -#: common.opt:1591 +#: common.opt:1595 msgid "Enable an RTL peephole pass before sched2" msgstr "" -#: common.opt:1595 +#: common.opt:1599 msgid "Generate position-independent code if possible (large mode)" msgstr "" -#: common.opt:1599 +#: common.opt:1603 msgid "" "Generate position-independent code for executables if possible (large mode)" msgstr "" -#: common.opt:1603 +#: common.opt:1607 msgid "Generate position-independent code if possible (small mode)" msgstr "" -#: common.opt:1607 +#: common.opt:1611 msgid "" "Generate position-independent code for executables if possible (small mode)" msgstr "" -#: common.opt:1611 +#: common.opt:1615 msgid "Specify a plugin to load" msgstr "" -#: common.opt:1615 +#: common.opt:1619 msgid "" "-fplugin-arg-<name>-<key>[=<value>]\tSpecify argument <key>=<value> for " "plugin <name>" msgstr "" -#: common.opt:1619 +#: common.opt:1623 msgid "Run predictive commoning optimization." msgstr "" -#: common.opt:1623 +#: common.opt:1627 msgid "Generate prefetch instructions, if available, for arrays in loops" msgstr "" -#: common.opt:1627 +#: common.opt:1631 msgid "Enable basic program profiling code" msgstr "" -#: common.opt:1631 +#: common.opt:1635 msgid "Insert arc-based program profiling code" msgstr "" -#: common.opt:1635 +#: common.opt:1639 msgid "Set the top-level directory for storing the profile data." msgstr "" -#: common.opt:1640 +#: common.opt:1644 msgid "Enable correction of flow inconsistent profile data input" msgstr "" -#: common.opt:1644 +#: common.opt:1648 msgid "" "Enable common options for generating profile info for profile feedback " "directed optimizations" msgstr "" -#: common.opt:1648 +#: common.opt:1652 msgid "" "Enable common options for generating profile info for profile feedback " "directed optimizations, and set -fprofile-dir=" msgstr "" -#: common.opt:1652 +#: common.opt:1656 msgid "" "Enable common options for performing profile feedback directed optimizations" msgstr "" -#: common.opt:1656 +#: common.opt:1660 msgid "" "Enable common options for performing profile feedback directed " "optimizations, and set -fprofile-dir=" msgstr "" -#: common.opt:1660 +#: common.opt:1664 msgid "Insert code to profile values of expressions" msgstr "" -#: common.opt:1664 +#: common.opt:1668 msgid "Report on consistency of profile" msgstr "" -#: common.opt:1671 +#: common.opt:1675 msgid "-frandom-seed=<string>\tMake compile reproducible using <string>" msgstr "" -#: common.opt:1681 +#: common.opt:1685 msgid "Record gcc command line switches in the object file." msgstr "" -#: common.opt:1685 +#: common.opt:1689 msgid "Return small aggregates in registers" msgstr "" -#: common.opt:1689 +#: common.opt:1693 msgid "Enables a register move optimization" msgstr "" -#: common.opt:1693 +#: common.opt:1697 msgid "Perform a register renaming optimization pass" msgstr "" -#: common.opt:1697 +#: common.opt:1701 msgid "Reorder basic blocks to improve code placement" msgstr "" -#: common.opt:1701 +#: common.opt:1705 msgid "Reorder basic blocks and partition into hot and cold sections" msgstr "" -#: common.opt:1705 +#: common.opt:1709 msgid "Reorder functions to improve code placement" msgstr "" -#: common.opt:1709 +#: common.opt:1713 msgid "Add a common subexpression elimination pass after loop optimizations" msgstr "" -#: common.opt:1717 +#: common.opt:1721 msgid "Disable optimizations that assume default FP rounding behavior" msgstr "" -#: common.opt:1721 +#: common.opt:1725 msgid "Enable scheduling across basic blocks" msgstr "" -#: common.opt:1725 +#: common.opt:1729 msgid "Enable register pressure sensitive insn scheduling" msgstr "" -#: common.opt:1729 +#: common.opt:1733 msgid "Allow speculative motion of non-loads" msgstr "" -#: common.opt:1733 +#: common.opt:1737 msgid "Allow speculative motion of some loads" msgstr "" -#: common.opt:1737 +#: common.opt:1741 msgid "Allow speculative motion of more loads" msgstr "" -#: common.opt:1741 +#: common.opt:1745 msgid "-fsched-verbose=<number>\tSet the verbosity level of the scheduler" msgstr "" -#: common.opt:1745 +#: common.opt:1749 msgid "If scheduling post reload, do superblock scheduling" msgstr "" -#: common.opt:1753 +#: common.opt:1757 msgid "Reschedule instructions before register allocation" msgstr "" -#: common.opt:1757 +#: common.opt:1761 msgid "Reschedule instructions after register allocation" msgstr "" -#: common.opt:1764 +#: common.opt:1768 msgid "Schedule instructions using selective scheduling algorithm" msgstr "" -#: common.opt:1768 +#: common.opt:1772 msgid "Run selective scheduling after reload" msgstr "" -#: common.opt:1772 +#: common.opt:1776 msgid "Perform software pipelining of inner loops during selective scheduling" msgstr "" -#: common.opt:1776 +#: common.opt:1780 msgid "Perform software pipelining of outer loops during selective scheduling" msgstr "" -#: common.opt:1780 +#: common.opt:1784 msgid "Reschedule pipelined regions without pipelining" msgstr "" -#: common.opt:1786 +#: common.opt:1790 msgid "Allow premature scheduling of queued insns" msgstr "" -#: common.opt:1790 +#: common.opt:1794 msgid "" "-fsched-stalled-insns=<number>\tSet number of queued insns that can be " "prematurely scheduled" msgstr "" -#: common.opt:1798 +#: common.opt:1802 msgid "" "Set dependence distance checking in premature scheduling of queued insns" msgstr "" -#: common.opt:1802 +#: common.opt:1806 msgid "" "-fsched-stalled-insns-dep=<number>\tSet dependence distance checking in " "premature scheduling of queued insns" msgstr "" -#: common.opt:1806 +#: common.opt:1810 msgid "Enable the group heuristic in the scheduler" msgstr "" -#: common.opt:1810 +#: common.opt:1814 msgid "Enable the critical path heuristic in the scheduler" msgstr "" -#: common.opt:1814 +#: common.opt:1818 msgid "Enable the speculative instruction heuristic in the scheduler" msgstr "" -#: common.opt:1818 +#: common.opt:1822 msgid "Enable the rank heuristic in the scheduler" msgstr "" -#: common.opt:1822 +#: common.opt:1826 msgid "Enable the last instruction heuristic in the scheduler" msgstr "" -#: common.opt:1826 +#: common.opt:1830 msgid "Enable the dependent count heuristic in the scheduler" msgstr "" -#: common.opt:1830 +#: common.opt:1834 msgid "Access data in the same section from shared anchor points" msgstr "" -#: common.opt:1842 +#: common.opt:1846 msgid "Turn on Redundant Extensions Elimination pass." msgstr "" -#: common.opt:1846 +#: common.opt:1850 msgid "Show column numbers in diagnostics, when available. Default on" msgstr "" -#: common.opt:1850 +#: common.opt:1854 msgid "Emit function prologues only before parts of the function that need it," msgstr "" -#: common.opt:1855 +#: common.opt:1859 msgid "Disable optimizations observable by IEEE signaling NaNs" msgstr "" -#: common.opt:1859 +#: common.opt:1863 msgid "" "Disable floating point optimizations that ignore the IEEE signedness of zero" msgstr "" -#: common.opt:1863 +#: common.opt:1867 msgid "Convert floating point constants to single precision constants" msgstr "" -#: common.opt:1867 +#: common.opt:1871 msgid "Split lifetimes of induction variables when loops are unrolled" msgstr "" -#: common.opt:1871 +#: common.opt:1875 msgid "Generate discontiguous stack frames" msgstr "" -#: common.opt:1875 +#: common.opt:1879 msgid "Split wide types into independent registers" msgstr "" -#: common.opt:1879 +#: common.opt:1883 msgid "Apply variable expansion when loops are unrolled" msgstr "" -#: common.opt:1883 +#: common.opt:1887 msgid "" "-fstack-check=[no|generic|specific]\tInsert stack checking code into the " "program" msgstr "" -#: common.opt:1887 +#: common.opt:1891 msgid "" "Insert stack checking code into the program. Same as -fstack-check=specific" msgstr "" -#: common.opt:1894 +#: common.opt:1898 msgid "" "-fstack-limit-register=<register>\tTrap if the stack goes past <register>" msgstr "" -#: common.opt:1898 +#: common.opt:1902 msgid "-fstack-limit-symbol=<name>\tTrap if the stack goes past symbol <name>" msgstr "" -#: common.opt:1902 +#: common.opt:1906 msgid "Use propolice as a stack protection method" msgstr "" -#: common.opt:1906 +#: common.opt:1910 msgid "Use a stack protection method for every function" msgstr "" -#: common.opt:1910 +#: common.opt:1914 msgid "Output stack usage information on a per-function basis" msgstr "" -#: common.opt:1922 +#: common.opt:1926 msgid "Assume strict aliasing rules apply" msgstr "" -#: common.opt:1926 +#: common.opt:1930 msgid "Treat signed overflow as undefined" msgstr "" -#: common.opt:1930 +#: common.opt:1934 msgid "Implement __atomic operations via libcalls to legacy __sync functions" msgstr "" -#: common.opt:1934 +#: common.opt:1938 msgid "Check for syntax errors, then stop" msgstr "" -#: common.opt:1938 +#: common.opt:1942 msgid "Create data files needed by \"gcov\"" msgstr "" -#: common.opt:1942 +#: common.opt:1946 msgid "Perform jump threading optimizations" msgstr "" -#: common.opt:1946 +#: common.opt:1950 msgid "Report the time taken by each compiler pass" msgstr "" -#: common.opt:1950 +#: common.opt:1954 msgid "" "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tSet the " "default thread-local storage code generation model" msgstr "" -#: common.opt:1953 +#: common.opt:1957 #, c-format msgid "unknown TLS model %qs" msgstr "" -#: common.opt:1969 +#: common.opt:1973 msgid "Reorder top level functions, variables, and asms" msgstr "" -#: common.opt:1973 +#: common.opt:1977 msgid "Perform superblock formation via tail duplication" msgstr "" -#: common.opt:1980 +#: common.opt:1984 msgid "Assume floating-point operations can trap" msgstr "" -#: common.opt:1984 +#: common.opt:1988 msgid "Trap for signed overflow in addition, subtraction and multiplication" msgstr "" -#: common.opt:1988 +#: common.opt:1992 msgid "Enable SSA-CCP optimization on trees" msgstr "" -#: common.opt:1992 +#: common.opt:1996 msgid "Enable SSA-BIT-CCP optimization on trees" msgstr "" -#: common.opt:2000 +#: common.opt:2004 msgid "Enable loop header copying on trees" msgstr "" -#: common.opt:2004 +#: common.opt:2008 msgid "Enable coalescing of copy-related user variables that are inlined" msgstr "" -#: common.opt:2008 +#: common.opt:2012 msgid "Enable coalescing of all copy-related user variables" msgstr "" -#: common.opt:2012 +#: common.opt:2016 msgid "Replace SSA temporaries with better names in copies" msgstr "" -#: common.opt:2016 +#: common.opt:2020 msgid "Enable copy propagation on trees" msgstr "" -#: common.opt:2024 +#: common.opt:2028 msgid "Transform condition stores into unconditional ones" msgstr "" -#: common.opt:2028 +#: common.opt:2032 msgid "Perform conversions of switch initializations." msgstr "" -#: common.opt:2032 +#: common.opt:2036 msgid "Enable SSA dead code elimination optimization on trees" msgstr "" -#: common.opt:2036 +#: common.opt:2040 msgid "Enable dominator optimizations" msgstr "" -#: common.opt:2040 +#: common.opt:2044 msgid "Enable tail merging on trees" msgstr "" -#: common.opt:2044 +#: common.opt:2048 msgid "Enable dead store elimination" msgstr "" -#: common.opt:2048 +#: common.opt:2052 msgid "Enable forward propagation on trees" msgstr "" -#: common.opt:2052 +#: common.opt:2056 msgid "Enable Full Redundancy Elimination (FRE) on trees" msgstr "" -#: common.opt:2056 +#: common.opt:2060 msgid "Enable string length optimizations on trees" msgstr "" -#: common.opt:2060 +#: common.opt:2064 msgid "Enable loop distribution on trees" msgstr "" -#: common.opt:2064 +#: common.opt:2068 msgid "Enable loop distribution for patterns transformed into a library call" msgstr "" -#: common.opt:2068 +#: common.opt:2072 msgid "Enable loop invariant motion on trees" msgstr "" -#: common.opt:2072 +#: common.opt:2076 msgid "Enable loop interchange transforms. Same as -floop-interchange" msgstr "" -#: common.opt:2076 +#: common.opt:2080 msgid "Create canonical induction variables in loops" msgstr "" -#: common.opt:2080 +#: common.opt:2084 msgid "Enable loop optimizations on tree level" msgstr "" -#: common.opt:2084 +#: common.opt:2088 msgid "Enable automatic parallelization of loops" msgstr "" -#: common.opt:2088 +#: common.opt:2092 msgid "Enable hoisting loads from conditional pointers." msgstr "" -#: common.opt:2092 +#: common.opt:2096 msgid "Enable SSA-PRE optimization on trees" msgstr "" -#: common.opt:2096 +#: common.opt:2100 msgid "" "In SSA-PRE optimization on trees, enable partial-partial redundancy " "elimination" msgstr "" -#: common.opt:2100 +#: common.opt:2104 msgid "Perform function-local points-to analysis on trees." msgstr "" -#: common.opt:2104 +#: common.opt:2108 msgid "Enable reassociation on tree level" msgstr "" -#: common.opt:2112 +#: common.opt:2116 msgid "Enable SSA code sinking on trees" msgstr "" -#: common.opt:2116 +#: common.opt:2120 msgid "Perform straight-line strength reduction" msgstr "" -#: common.opt:2120 +#: common.opt:2124 msgid "Perform scalar replacement of aggregates" msgstr "" -#: common.opt:2124 +#: common.opt:2128 msgid "Replace temporary expressions in the SSA->normal pass" msgstr "" -#: common.opt:2128 +#: common.opt:2132 msgid "Perform live range splitting during the SSA->normal pass" msgstr "" -#: common.opt:2132 +#: common.opt:2136 msgid "Perform Value Range Propagation on trees" msgstr "" -#: common.opt:2136 +#: common.opt:2140 msgid "Compile whole compilation unit at a time" msgstr "" -#: common.opt:2140 +#: common.opt:2144 msgid "Perform loop unrolling when iteration count is known" msgstr "" -#: common.opt:2144 +#: common.opt:2148 msgid "Perform loop unrolling for all loops" msgstr "" -#: common.opt:2151 +#: common.opt:2155 msgid "Allow loop optimizations to assume that the loops behave in normal way" msgstr "" -#: common.opt:2155 +#: common.opt:2159 msgid "Allow optimization for floating-point arithmetic which may change the" msgstr "" -#: common.opt:2160 +#: common.opt:2164 msgid "Same as -fassociative-math for expressions which include division." msgstr "" -#: common.opt:2168 +#: common.opt:2172 msgid "Allow math optimizations that may violate IEEE or ISO standards" msgstr "" -#: common.opt:2172 +#: common.opt:2176 msgid "Perform loop unswitching" msgstr "" -#: common.opt:2176 +#: common.opt:2180 msgid "Just generate unwind tables for exception handling" msgstr "" -#: common.opt:2180 +#: common.opt:2184 msgid "Use the bfd linker instead of the default linker" msgstr "" -#: common.opt:2184 +#: common.opt:2188 msgid "Use the gold linker instead of the default linker" msgstr "" -#: common.opt:2196 +#: common.opt:2200 msgid "Perform variable tracking" msgstr "" -#: common.opt:2204 +#: common.opt:2208 msgid "Perform variable tracking by annotating assignments" msgstr "" -#: common.opt:2210 +#: common.opt:2214 msgid "Toggle -fvar-tracking-assignments" msgstr "" -#: common.opt:2218 +#: common.opt:2222 msgid "Perform variable tracking and also tag variables that are uninitialized" msgstr "" -#: common.opt:2222 +#: common.opt:2226 msgid "Enable loop vectorization on trees" msgstr "" -#: common.opt:2226 +#: common.opt:2230 msgid "" "-ftree-vectorizer-verbose=<number>\tThis switch is deprecated. Use -fopt-" "info instead." msgstr "" -#: common.opt:2230 +#: common.opt:2234 msgid "Enable basic block vectorization (SLP) on trees" msgstr "" -#: common.opt:2234 +#: common.opt:2238 msgid "Enable use of cost model in vectorization" msgstr "" -#: common.opt:2238 +#: common.opt:2242 msgid "Enable loop versioning when doing loop vectorization on trees" msgstr "" -#: common.opt:2242 +#: common.opt:2246 msgid "Enable copy propagation of scalar-evolution information." msgstr "" -#: common.opt:2252 +#: common.opt:2256 msgid "Add extra commentary to assembler output" msgstr "" -#: common.opt:2256 +#: common.opt:2260 msgid "" "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol " "visibility" msgstr "" -#: common.opt:2259 +#: common.opt:2263 #, c-format msgid "unrecognized visibility value %qs" msgstr "" -#: common.opt:2275 +#: common.opt:2279 msgid "Use expression value profiles in optimizations" msgstr "" -#: common.opt:2279 +#: common.opt:2283 msgid "Construct webs and split unrelated uses of single variable" msgstr "" -#: common.opt:2283 +#: common.opt:2287 msgid "Enable conditional dead code elimination for builtin calls" msgstr "" -#: common.opt:2287 +#: common.opt:2291 msgid "Perform whole program optimizations" msgstr "" -#: common.opt:2291 +#: common.opt:2295 msgid "Assume signed arithmetic overflow wraps around" msgstr "" -#: common.opt:2295 +#: common.opt:2299 msgid "Put zero initialized data in the bss section" msgstr "" -#: common.opt:2299 +#: common.opt:2303 msgid "Generate debug information in default format" msgstr "" -#: common.opt:2303 +#: common.opt:2307 msgid "Generate debug information in COFF format" msgstr "" -#: common.opt:2307 +#: common.opt:2311 msgid "Generate debug information in DWARF v2 (or later) format" msgstr "" -#: common.opt:2311 +#: common.opt:2315 msgid "Generate debug information in default extended format" msgstr "" -#: common.opt:2315 +#: common.opt:2319 msgid "Don't generate DWARF pubnames and pubtypes sections." msgstr "" -#: common.opt:2319 +#: common.opt:2323 msgid "Generate DWARF pubnames and pubtypes sections." msgstr "" -#: common.opt:2323 +#: common.opt:2327 msgid "Don't record gcc command line switches in DWARF DW_AT_producer." msgstr "" -#: common.opt:2327 +#: common.opt:2331 msgid "Record gcc command line switches in DWARF DW_AT_producer." msgstr "" -#: common.opt:2331 +#: common.opt:2335 msgid "Don't generate debug information in separate .dwo files" msgstr "" -#: common.opt:2335 +#: common.opt:2339 msgid "Generate debug information in separate .dwo files" msgstr "" -#: common.opt:2339 +#: common.opt:2343 msgid "Generate debug information in STABS format" msgstr "" -#: common.opt:2343 +#: common.opt:2347 msgid "Generate debug information in extended STABS format" msgstr "" -#: common.opt:2347 +#: common.opt:2351 msgid "Emit DWARF additions beyond selected version" msgstr "" -#: common.opt:2351 +#: common.opt:2355 msgid "Don't emit DWARF additions beyond selected version" msgstr "" -#: common.opt:2355 +#: common.opt:2359 msgid "Toggle debug information generation" msgstr "" -#: common.opt:2359 +#: common.opt:2363 msgid "Generate debug information in VMS format" msgstr "" -#: common.opt:2363 +#: common.opt:2367 msgid "Generate debug information in XCOFF format" msgstr "" -#: common.opt:2367 +#: common.opt:2371 msgid "Generate debug information in extended XCOFF format" msgstr "" -#: common.opt:2374 +#: common.opt:2378 msgid "-iplugindir=<dir>\tSet <dir> to be the default plugin directory" msgstr "" -#: common.opt:2378 +#: common.opt:2382 msgid "-imultiarch <dir>\tSet <dir> to be the multiarch include subdirectory" msgstr "" -#: common.opt:2400 +#: common.opt:2404 msgid "-o <file>\tPlace output into <file>" msgstr "" -#: common.opt:2404 +#: common.opt:2408 msgid "Enable function profiling" msgstr "" -#: common.opt:2414 +#: common.opt:2418 msgid "Like -pedantic but issue them as errors" msgstr "" -#: common.opt:2454 +#: common.opt:2458 msgid "Do not display functions compiled or elapsed time" msgstr "" -#: common.opt:2486 +#: common.opt:2490 msgid "Enable verbose output" msgstr "" -#: common.opt:2490 +#: common.opt:2494 msgid "Display the compiler's version" msgstr "" -#: common.opt:2494 +#: common.opt:2498 msgid "Suppress warnings" msgstr "" -#: common.opt:2504 +#: common.opt:2508 msgid "Create a shared library" msgstr "" -#: common.opt:2543 +#: common.opt:2547 msgid "Create a position independent executable" msgstr "" -#: go/gofrontend/expressions.cc:102 c-family/c-common.c:1777 cp/cvt.c:1149 +#: go/gofrontend/expressions.cc:102 c-family/c-common.c:1782 cp/cvt.c:1149 #: cp/cvt.c:1395 #, gcc-internal-format msgid "value computed is not used" @@ -13105,7 +13123,7 @@ msgid "method %s%s%s is marked go:nointerface" msgstr "" #. 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 +#: attribs.c:426 c-family/c-common.c:8041 objc/objc-act.c:4952 #: objc/objc-act.c:6922 objc/objc-act.c:8109 objc/objc-act.c:8160 #, gcc-internal-format msgid "%qE attribute directive ignored" @@ -13306,7 +13324,7 @@ msgstr "" #. All valid uses of __builtin_va_arg_pack () are removed during #. inlining. -#: builtins.c:6025 expr.c:10184 +#: builtins.c:6025 expr.c:10185 #, gcc-internal-format msgid "%Kinvalid use of %<__builtin_va_arg_pack ()%>" msgstr "" @@ -13395,17 +13413,17 @@ msgstr "" msgid "function call has aggregate value" msgstr "" -#: cfgexpand.c:1238 function.c:971 varasm.c:1966 +#: cfgexpand.c:1238 function.c:971 varasm.c:1964 #, gcc-internal-format msgid "size of variable %q+D is too large" msgstr "" -#: cfgexpand.c:4487 +#: cfgexpand.c:4542 #, gcc-internal-format msgid "stack protector not protecting local variables: variable length buffer" msgstr "" -#: cfgexpand.c:4491 +#: cfgexpand.c:4546 #, gcc-internal-format, gfc-internal-format msgid "" "stack protector not protecting function: all local arrays are less than %d " @@ -13707,162 +13725,162 @@ msgstr "" msgid "%d exits recorded for loop %d (having %d exits)" msgstr "" -#: cfgrtl.c:2092 +#: cfgrtl.c:2090 #, gcc-internal-format, gfc-internal-format msgid "BB_RTL flag not set for block %d" msgstr "" -#: cfgrtl.c:2099 +#: cfgrtl.c:2097 #, gcc-internal-format, gfc-internal-format msgid "insn %d basic block pointer is %d, should be %d" msgstr "" -#: cfgrtl.c:2110 +#: cfgrtl.c:2108 #, gcc-internal-format, gfc-internal-format msgid "insn %d in header of bb %d has non-NULL basic block" msgstr "" -#: cfgrtl.c:2118 +#: cfgrtl.c:2116 #, gcc-internal-format, gfc-internal-format msgid "insn %d in footer of bb %d has non-NULL basic block" msgstr "" -#: cfgrtl.c:2141 +#: cfgrtl.c:2139 #, gcc-internal-format msgid "verify_flow_info: REG_BR_PROB does not match cfg %wi %i" msgstr "" -#: cfgrtl.c:2160 +#: cfgrtl.c:2158 #, gcc-internal-format msgid "EDGE_CROSSING incorrectly set across same section" msgstr "" -#: cfgrtl.c:2165 +#: cfgrtl.c:2163 #, gcc-internal-format, gfc-internal-format msgid "fallthru edge crosses section boundary in bb %i" msgstr "" -#: cfgrtl.c:2171 +#: cfgrtl.c:2169 #, gcc-internal-format, gfc-internal-format msgid "EH edge crosses section boundary in bb %i" msgstr "" -#: cfgrtl.c:2178 +#: cfgrtl.c:2176 #, gcc-internal-format msgid "EDGE_CROSSING missing across section boundary" msgstr "" -#: cfgrtl.c:2205 +#: cfgrtl.c:2203 #, gcc-internal-format, gfc-internal-format msgid "missing REG_EH_REGION note at the end of bb %i" msgstr "" -#: cfgrtl.c:2210 +#: cfgrtl.c:2208 #, gcc-internal-format, gfc-internal-format msgid "too many exception handling edges in bb %i" msgstr "" -#: cfgrtl.c:2218 +#: cfgrtl.c:2216 #, gcc-internal-format, gfc-internal-format msgid "too many outgoing branch edges from bb %i" msgstr "" -#: cfgrtl.c:2223 +#: cfgrtl.c:2221 #, gcc-internal-format, gfc-internal-format msgid "fallthru edge after unconditional jump in bb %i" msgstr "" -#: cfgrtl.c:2228 +#: cfgrtl.c:2226 #, gcc-internal-format, gfc-internal-format msgid "wrong number of branch edges after unconditional jump in bb %i" msgstr "" -#: cfgrtl.c:2235 +#: cfgrtl.c:2233 #, gcc-internal-format, gfc-internal-format msgid "wrong amount of branch edges after conditional jump in bb %i" msgstr "" -#: cfgrtl.c:2241 +#: cfgrtl.c:2239 #, gcc-internal-format, gfc-internal-format msgid "abnormal call edges for non-call insn in bb %i" msgstr "" -#: cfgrtl.c:2246 +#: cfgrtl.c:2244 #, gcc-internal-format, gfc-internal-format msgid "sibcall edges for non-call insn in bb %i" msgstr "" -#: cfgrtl.c:2256 +#: cfgrtl.c:2254 #, gcc-internal-format, gfc-internal-format msgid "abnormal edges for no purpose in bb %i" msgstr "" -#: cfgrtl.c:2268 +#: cfgrtl.c:2266 #, gcc-internal-format, gfc-internal-format msgid "insn %d inside basic block %d but block_for_insn is NULL" msgstr "" -#: cfgrtl.c:2272 +#: cfgrtl.c:2270 #, gcc-internal-format, gfc-internal-format msgid "insn %d inside basic block %d but block_for_insn is %i" msgstr "" -#: cfgrtl.c:2286 cfgrtl.c:2296 +#: cfgrtl.c:2284 cfgrtl.c:2294 #, gcc-internal-format, gfc-internal-format msgid "NOTE_INSN_BASIC_BLOCK is missing for block %d" msgstr "" -#: cfgrtl.c:2309 +#: cfgrtl.c:2307 #, gcc-internal-format, gfc-internal-format msgid "NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d" msgstr "" -#: cfgrtl.c:2319 +#: cfgrtl.c:2317 #, gcc-internal-format, gfc-internal-format msgid "in basic block %d:" msgstr "" -#: cfgrtl.c:2371 cfgrtl.c:2461 +#: cfgrtl.c:2369 cfgrtl.c:2459 #, gcc-internal-format, gfc-internal-format msgid "insn %d outside of basic blocks has non-NULL bb field" msgstr "" -#: cfgrtl.c:2379 +#: cfgrtl.c:2377 #, gcc-internal-format, gfc-internal-format msgid "end insn %d for block %d not found in the insn stream" msgstr "" -#: cfgrtl.c:2392 +#: cfgrtl.c:2390 #, gcc-internal-format, gfc-internal-format msgid "insn %d is in multiple basic blocks (%d and %d)" msgstr "" -#: cfgrtl.c:2404 +#: cfgrtl.c:2402 #, gcc-internal-format, gfc-internal-format msgid "head insn %d for block %d not found in the insn stream" msgstr "" -#: cfgrtl.c:2421 +#: cfgrtl.c:2419 #, gcc-internal-format, gfc-internal-format msgid "missing barrier after block %i" msgstr "" -#: cfgrtl.c:2437 +#: cfgrtl.c:2435 #, gcc-internal-format, gfc-internal-format msgid "verify_flow_info: Incorrect blocks for fallthru %i->%i" msgstr "" -#: cfgrtl.c:2446 +#: cfgrtl.c:2444 #, gcc-internal-format, gfc-internal-format msgid "verify_flow_info: Incorrect fallthru %i->%i" msgstr "" -#: cfgrtl.c:2479 +#: cfgrtl.c:2477 #, gcc-internal-format msgid "basic blocks not laid down consecutively" msgstr "" -#: cfgrtl.c:2516 +#: cfgrtl.c:2514 #, gcc-internal-format, gfc-internal-format msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)" msgstr "" @@ -14136,7 +14154,7 @@ msgstr "" msgid "no arguments" msgstr "" -#: collect2.c:1284 opts.c:794 +#: collect2.c:1284 opts.c:797 #, gcc-internal-format msgid "LTO support has not been enabled in this configuration" msgstr "" @@ -14191,12 +14209,12 @@ msgstr "" msgid "cannot find '%s'" msgstr "" -#: collect2.c:1921 collect2.c:2448 collect2.c:2644 gcc.c:2749 +#: collect2.c:1921 collect2.c:2448 collect2.c:2644 gcc.c:2750 #, gcc-internal-format msgid "pex_init failed: %m" msgstr "" -#: collect2.c:1930 collect2.c:2457 collect2.c:2652 gcc.c:7188 +#: collect2.c:1930 collect2.c:2457 collect2.c:2652 gcc.c:7191 #, gcc-internal-format msgid "%s: %m" msgstr "" @@ -14442,7 +14460,7 @@ msgstr "" msgid "global constructors not supported on this target" msgstr "" -#: diagnostic.c:1145 +#: diagnostic.c:1148 #, gcc-internal-format, gfc-internal-format msgid "in %s, at %s:%d" msgstr "" @@ -14489,22 +14507,22 @@ msgstr "" msgid "non-delegitimized UNSPEC %s (%d) found in variable location" msgstr "" -#: emit-rtl.c:2612 +#: emit-rtl.c:2616 #, gcc-internal-format msgid "invalid rtl sharing found in the insn" msgstr "" -#: emit-rtl.c:2614 +#: emit-rtl.c:2618 #, gcc-internal-format msgid "shared rtx" msgstr "" -#: emit-rtl.c:2616 +#: emit-rtl.c:2620 #, gcc-internal-format msgid "internal consistency failure" msgstr "" -#: emit-rtl.c:3741 +#: emit-rtl.c:3749 #, gcc-internal-format msgid "ICE: emit_insn used where emit_jump_insn needed:\n" msgstr "" @@ -14514,57 +14532,57 @@ msgstr "" msgid "abort in %s, at %s:%d" msgstr "" -#: except.c:2026 +#: except.c:2075 #, gcc-internal-format msgid "argument of %<__builtin_eh_return_regno%> must be constant" msgstr "" -#: except.c:2163 +#: except.c:2212 #, gcc-internal-format msgid "__builtin_eh_return not supported on this target" msgstr "" -#: except.c:3222 except.c:3247 +#: except.c:3271 except.c:3296 #, gcc-internal-format, gfc-internal-format msgid "region_array is corrupted for region %i" msgstr "" -#: except.c:3235 except.c:3266 +#: except.c:3284 except.c:3315 #, gcc-internal-format, gfc-internal-format msgid "lp_array is corrupted for lp %i" msgstr "" -#: except.c:3252 +#: except.c:3301 #, gcc-internal-format, gfc-internal-format msgid "outer block of region %i is wrong" msgstr "" -#: except.c:3257 +#: except.c:3306 #, gcc-internal-format, gfc-internal-format msgid "negative nesting depth of region %i" msgstr "" -#: except.c:3271 +#: except.c:3320 #, gcc-internal-format, gfc-internal-format msgid "region of lp %i is wrong" msgstr "" -#: except.c:3298 +#: except.c:3347 #, gcc-internal-format, gfc-internal-format msgid "tree list ends on depth %i" msgstr "" -#: except.c:3303 +#: except.c:3352 #, gcc-internal-format msgid "region_array does not match region_tree" msgstr "" -#: except.c:3308 +#: except.c:3357 #, gcc-internal-format msgid "lp_array does not match region_tree" msgstr "" -#: except.c:3315 +#: except.c:3364 #, gcc-internal-format msgid "verify_eh_tree failed" msgstr "" @@ -14610,12 +14628,12 @@ msgstr "" msgid "local frame unavailable (naked function?)" msgstr "" -#: expr.c:10191 +#: expr.c:10192 #, gcc-internal-format msgid "%Kcall to %qs declared with attribute error: %s" msgstr "" -#: expr.c:10198 +#: expr.c:10199 #, gcc-internal-format msgid "%Kcall to %qs declared with attribute warning: %s" msgstr "" @@ -14650,52 +14668,52 @@ msgstr "" msgid "assuming signed overflow does not occur when negating a division" msgstr "" -#: fold-const.c:3437 fold-const.c:3449 +#: fold-const.c:3450 fold-const.c:3462 #, gcc-internal-format, gfc-internal-format msgid "comparison is always %d due to width of bit-field" msgstr "" -#: fold-const.c:4849 tree-ssa-reassoc.c:1943 +#: fold-const.c:4862 tree-ssa-reassoc.c:1944 #, gcc-internal-format msgid "assuming signed overflow does not occur when simplifying range test" msgstr "" -#: fold-const.c:5285 fold-const.c:5299 +#: fold-const.c:5298 fold-const.c:5312 #, gcc-internal-format, gfc-internal-format msgid "comparison is always %d" msgstr "" -#: fold-const.c:5432 +#: fold-const.c:5445 #, gcc-internal-format msgid "%<or%> of unmatched not-equal tests is always 1" msgstr "" -#: fold-const.c:5437 +#: fold-const.c:5450 #, gcc-internal-format msgid "%<and%> of mutually exclusive equal-tests is always 0" msgstr "" -#: fold-const.c:8729 +#: fold-const.c:8742 #, gcc-internal-format msgid "" "assuming signed overflow does not occur when reducing constant in comparison" msgstr "" -#: fold-const.c:8887 +#: fold-const.c:8900 #, gcc-internal-format msgid "" "assuming signed overflow does not occur when changing X +- C1 cmp C2 to X " "cmp C1 +- C2" msgstr "" -#: fold-const.c:9150 +#: fold-const.c:9163 #, gcc-internal-format msgid "" "assuming signed overflow does not occur when combining constants around a " "comparison" msgstr "" -#: fold-const.c:14564 +#: fold-const.c:14577 #, gcc-internal-format msgid "fold check: original tree changed by fold" msgstr "" @@ -14720,142 +14738,142 @@ msgstr "" msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>" msgstr "" -#: function.c:4631 +#: function.c:4620 #, gcc-internal-format msgid "function returns an aggregate" msgstr "" -#: function.c:4993 +#: function.c:4982 #, gcc-internal-format msgid "unused parameter %q+D" msgstr "" -#: gcc.c:1804 gcc.c:1824 +#: gcc.c:1805 gcc.c:1825 #, gcc-internal-format, gfc-internal-format msgid "specs %%include syntax malformed after %ld characters" msgstr "" -#: gcc.c:1850 gcc.c:1859 gcc.c:1869 gcc.c:1879 +#: gcc.c:1851 gcc.c:1860 gcc.c:1870 gcc.c:1880 #, gcc-internal-format, gfc-internal-format msgid "specs %%rename syntax malformed after %ld characters" msgstr "" -#: gcc.c:1889 +#: gcc.c:1890 #, gcc-internal-format, gfc-internal-format msgid "specs %s spec was not found to be renamed" msgstr "" -#: gcc.c:1896 +#: gcc.c:1897 #, gcc-internal-format msgid "%s: attempt to rename spec %qs to already defined spec %qs" msgstr "" -#: gcc.c:1917 +#: gcc.c:1918 #, gcc-internal-format, gfc-internal-format msgid "specs unknown %% command after %ld characters" msgstr "" -#: gcc.c:1928 gcc.c:1941 +#: gcc.c:1929 gcc.c:1942 #, gcc-internal-format, gfc-internal-format msgid "specs file malformed after %ld characters" msgstr "" -#: gcc.c:1993 +#: gcc.c:1994 #, gcc-internal-format msgid "spec file has no spec for linking" msgstr "" -#: gcc.c:2538 +#: gcc.c:2539 #, gcc-internal-format msgid "system path %qs is not absolute" msgstr "" -#: gcc.c:2626 +#: gcc.c:2627 #, gcc-internal-format msgid "-pipe not supported" msgstr "" -#: gcc.c:2788 +#: gcc.c:2789 #, gcc-internal-format msgid "failed to get exit status: %m" msgstr "" -#: gcc.c:2794 +#: gcc.c:2795 #, gcc-internal-format msgid "failed to get process times: %m" msgstr "" -#: gcc.c:2820 +#: gcc.c:2821 #, gcc-internal-format, gfc-internal-format msgid "%s (program %s)" msgstr "" -#: gcc.c:3251 opts-common.c:986 opts-common.c:1058 +#: gcc.c:3252 opts-common.c:1019 opts-common.c:1091 #, gcc-internal-format msgid "unrecognized command line option %qs" msgstr "" -#: gcc.c:3506 +#: gcc.c:3507 #, gcc-internal-format msgid "%qs is an unknown -save-temps option" msgstr "" -#: gcc.c:3967 +#: gcc.c:3968 #, gcc-internal-format msgid "-pipe ignored because -save-temps specified" msgstr "" -#: gcc.c:4055 +#: gcc.c:4056 #, gcc-internal-format msgid "%<-x %s%> after last input file has no effect" msgstr "" -#: gcc.c:4217 +#: gcc.c:4218 #, gcc-internal-format msgid "unable to locate default linker script %qs in the library search paths" msgstr "" -#: gcc.c:4421 +#: gcc.c:4422 #, gcc-internal-format msgid "switch %qs does not start with %<-%>" msgstr "" -#: gcc.c:4424 +#: gcc.c:4425 #, gcc-internal-format msgid "spec-generated switch is just %<-%>" msgstr "" -#: gcc.c:4515 +#: gcc.c:4516 #, gcc-internal-format, gfc-internal-format msgid "could not open temporary response file %s" msgstr "" -#: gcc.c:4521 +#: gcc.c:4522 #, gcc-internal-format, gfc-internal-format msgid "could not write to temporary response file %s" msgstr "" -#: gcc.c:4527 +#: gcc.c:4528 #, gcc-internal-format, gfc-internal-format msgid "could not close temporary response file %s" msgstr "" -#: gcc.c:4650 +#: gcc.c:4651 #, gcc-internal-format msgid "spec %qs invalid" msgstr "" -#: gcc.c:4799 +#: gcc.c:4800 #, gcc-internal-format msgid "spec %qs has invalid %<%%0%c%>" msgstr "" -#: gcc.c:5118 +#: gcc.c:5119 #, gcc-internal-format msgid "spec %qs has invalid %<%%W%c%>" msgstr "" -#: gcc.c:5140 +#: gcc.c:5141 #, gcc-internal-format msgid "spec %qs has invalid %<%%x%c%>" msgstr "" @@ -14863,220 +14881,220 @@ msgstr "" #. Catch the case where a spec string contains something like #. '%{foo:%*}'. i.e. there is no * in the pattern on the left #. hand side of the :. -#: gcc.c:5341 +#: gcc.c:5342 #, gcc-internal-format msgid "spec failure: %<%%*%> has not been initialized by pattern match" msgstr "" -#: gcc.c:5384 +#: gcc.c:5385 #, gcc-internal-format msgid "spec failure: unrecognized spec option %qc" msgstr "" -#: gcc.c:5446 +#: gcc.c:5447 #, gcc-internal-format msgid "unknown spec function %qs" msgstr "" -#: gcc.c:5476 +#: gcc.c:5477 #, gcc-internal-format msgid "error in args to spec function %qs" msgstr "" -#: gcc.c:5527 +#: gcc.c:5528 #, gcc-internal-format msgid "malformed spec function name" msgstr "" #. ) -#: gcc.c:5530 +#: gcc.c:5531 #, gcc-internal-format msgid "no arguments for spec function" msgstr "" -#: gcc.c:5549 +#: gcc.c:5550 #, gcc-internal-format msgid "malformed spec function arguments" msgstr "" -#: gcc.c:5810 +#: gcc.c:5811 #, gcc-internal-format msgid "braced spec %qs is invalid at %qc" msgstr "" -#: gcc.c:5898 +#: gcc.c:5899 #, gcc-internal-format msgid "braced spec body %qs is invalid" msgstr "" -#: gcc.c:6151 +#: gcc.c:6152 #, gcc-internal-format, gfc-internal-format msgid "%s: could not determine length of compare-debug file %s" msgstr "" -#: gcc.c:6162 +#: gcc.c:6163 #, gcc-internal-format, gfc-internal-format msgid "%s: -fcompare-debug failure (length)" msgstr "" -#: gcc.c:6172 gcc.c:6213 +#: gcc.c:6173 gcc.c:6214 #, gcc-internal-format, gfc-internal-format msgid "%s: could not open compare-debug file %s" msgstr "" -#: gcc.c:6192 gcc.c:6229 +#: gcc.c:6193 gcc.c:6230 #, gcc-internal-format, gfc-internal-format msgid "%s: -fcompare-debug failure" msgstr "" -#: gcc.c:6304 +#: gcc.c:6305 #, gcc-internal-format msgid "atexit failed" msgstr "" -#: gcc.c:6453 +#: gcc.c:6454 #, gcc-internal-format msgid "spec failure: more than one arg to SYSROOT_SUFFIX_SPEC" msgstr "" -#: gcc.c:6477 +#: gcc.c:6478 #, gcc-internal-format msgid "spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC" msgstr "" -#: gcc.c:6643 +#: gcc.c:6645 #, gcc-internal-format msgid "unrecognized command line option %<-%s%>" msgstr "" #. The error status indicates that only one set of fixed #. headers should be built. -#: gcc.c:6729 +#: gcc.c:6731 #, gcc-internal-format msgid "not configured with sysroot headers suffix" msgstr "" -#: gcc.c:6812 +#: gcc.c:6814 #, gcc-internal-format msgid "no input files" msgstr "" -#: gcc.c:6861 +#: gcc.c:6863 #, gcc-internal-format msgid "cannot specify -o with -c, -S or -E with multiple files" msgstr "" -#: gcc.c:6891 +#: gcc.c:6893 #, gcc-internal-format, gfc-internal-format msgid "%s: %s compiler not installed on this system" msgstr "" -#: gcc.c:6913 +#: gcc.c:6915 #, gcc-internal-format msgid "recompiling with -fcompare-debug" msgstr "" -#: gcc.c:6929 +#: gcc.c:6931 #, gcc-internal-format msgid "during -fcompare-debug recompilation" msgstr "" -#: gcc.c:6938 +#: gcc.c:6940 #, gcc-internal-format msgid "comparing final insns dumps" msgstr "" -#: gcc.c:7044 +#: gcc.c:7046 #, gcc-internal-format, gfc-internal-format msgid "-fuse-linker-plugin, but %s not found" msgstr "" -#: gcc.c:7076 +#: gcc.c:7079 #, gcc-internal-format, gfc-internal-format msgid "%s: linker input file unused because linking not done" msgstr "" -#: gcc.c:7117 +#: gcc.c:7120 #, gcc-internal-format, gfc-internal-format msgid "language %s not recognized" msgstr "" -#: gcc.c:7344 +#: gcc.c:7347 #, gcc-internal-format msgid "multilib spec %qs is invalid" msgstr "" -#: gcc.c:7538 +#: gcc.c:7541 #, gcc-internal-format msgid "multilib exclusions %qs is invalid" msgstr "" -#: gcc.c:7602 +#: gcc.c:7605 #, gcc-internal-format msgid "multilib select %qs %qs is invalid" msgstr "" -#: gcc.c:7758 +#: gcc.c:7761 #, gcc-internal-format msgid "multilib select %qs is invalid" msgstr "" -#: gcc.c:7797 +#: gcc.c:7800 #, gcc-internal-format msgid "multilib exclusion %qs is invalid" msgstr "" -#: gcc.c:8003 +#: gcc.c:8006 #, gcc-internal-format msgid "environment variable %qs not defined" msgstr "" -#: gcc.c:8115 gcc.c:8120 +#: gcc.c:8118 gcc.c:8123 #, gcc-internal-format msgid "invalid version number %qs" msgstr "" -#: gcc.c:8163 +#: gcc.c:8166 #, gcc-internal-format, gfc-internal-format msgid "too few arguments to %%:version-compare" msgstr "" -#: gcc.c:8169 +#: gcc.c:8172 #, gcc-internal-format, gfc-internal-format msgid "too many arguments to %%:version-compare" msgstr "" -#: gcc.c:8210 +#: gcc.c:8213 #, gcc-internal-format msgid "unknown operator %qs in %%:version-compare" msgstr "" -#: gcc.c:8333 +#: gcc.c:8336 #, gcc-internal-format, gfc-internal-format msgid "too many arguments to %%:compare-debug-dump-opt" msgstr "" -#: gcc.c:8405 +#: gcc.c:8408 #, gcc-internal-format, gfc-internal-format msgid "too many arguments to %%:compare-debug-self-opt" msgstr "" -#: gcc.c:8440 +#: gcc.c:8443 #, gcc-internal-format, gfc-internal-format msgid "too few arguments to %%:compare-debug-auxbase-opt" msgstr "" -#: gcc.c:8443 +#: gcc.c:8446 #, gcc-internal-format, gfc-internal-format msgid "too many arguments to %%:compare-debug-auxbase-opt" msgstr "" -#: gcc.c:8450 +#: gcc.c:8453 #, gcc-internal-format, gfc-internal-format msgid "argument to %%:compare-debug-auxbase-opt does not end in .gk" msgstr "" -#: gcc.c:8524 +#: gcc.c:8527 #, gcc-internal-format, gfc-internal-format msgid "too few arguments to %%:replace-extension" msgstr "" @@ -15097,13 +15115,13 @@ msgstr "" msgid "can%'t write padding to PCH file: %m" msgstr "" -#: ggc-common.c:615 ggc-common.c:623 ggc-common.c:630 ggc-common.c:633 -#: ggc-common.c:643 ggc-common.c:646 ggc-page.c:2439 +#: ggc-common.c:681 ggc-common.c:689 ggc-common.c:696 ggc-common.c:699 +#: ggc-common.c:709 ggc-common.c:712 ggc-page.c:2439 #, gcc-internal-format msgid "can%'t read PCH file: %m" msgstr "" -#: ggc-common.c:638 +#: ggc-common.c:704 #, gcc-internal-format msgid "had to relocate PCH" msgstr "" @@ -15255,7 +15273,7 @@ msgstr "" #. Fatal error here. We do not want to support compiling ltrans units with #. different version of compiler or different flags than the WPA unit, so #. this should never happen. -#: ipa-reference.c:1148 +#: ipa-reference.c:1146 #, gcc-internal-format msgid "ipa reference summary is missing in ltrans unit" msgstr "" @@ -15461,27 +15479,27 @@ msgstr "" msgid "invalid branch to/from an OpenMP structured block" msgstr "" -#: opts-common.c:997 +#: opts-common.c:1030 #, gcc-internal-format msgid "command line option %qs is not supported by this configuration" msgstr "" -#: opts-common.c:1007 +#: opts-common.c:1040 #, gcc-internal-format msgid "missing argument to %qs" msgstr "" -#: opts-common.c:1013 +#: opts-common.c:1046 #, gcc-internal-format msgid "argument to %qs should be a non-negative integer" msgstr "" -#: opts-common.c:1028 +#: opts-common.c:1061 #, gcc-internal-format msgid "unrecognized argument in option %qs" msgstr "" -#: opts-common.c:1044 +#: opts-common.c:1077 #, gcc-internal-format msgid "valid arguments to %qs are: %s" msgstr "" @@ -15539,142 +15557,142 @@ msgid "" "femit-struct-debug-detailed=ind:...%>" msgstr "" -#: opts.c:542 +#: opts.c:544 #, gcc-internal-format msgid "" "argument to %<-O%> should be a non-negative integer, %<g%>, %<s%> or %<fast%>" msgstr "" -#: opts.c:669 +#: opts.c:672 #, gcc-internal-format msgid "section anchors must be disabled when unit-at-a-time is disabled" msgstr "" -#: opts.c:673 +#: opts.c:676 #, gcc-internal-format msgid "toplevel reorder must be disabled when unit-at-a-time is disabled" msgstr "" -#: opts.c:679 +#: opts.c:682 #, gcc-internal-format msgid "transactional memory is not supported with non-call exceptions" msgstr "" -#: opts.c:694 +#: opts.c:697 #, gcc-internal-format msgid "section anchors must be disabled when toplevel reorder is disabled" msgstr "" -#: opts.c:729 config/darwin.c:3061 config/sh/sh.c:936 +#: opts.c:732 config/darwin.c:3061 config/sh/sh.c:933 #, gcc-internal-format msgid "" "-freorder-blocks-and-partition does not work with exceptions on this " "architecture" msgstr "" -#: opts.c:744 config/sh/sh.c:944 +#: opts.c:747 config/sh/sh.c:941 #, gcc-internal-format msgid "" "-freorder-blocks-and-partition does not support unwind info on this " "architecture" msgstr "" -#: opts.c:761 config/pa/pa.c:526 +#: opts.c:764 config/pa/pa.c:526 #, gcc-internal-format msgid "-freorder-blocks-and-partition does not work on this architecture" msgstr "" -#: opts.c:797 +#: opts.c:800 #, gcc-internal-format msgid "-fno-fat-lto-objects are supported only with linker plugin." msgstr "" -#: opts.c:805 +#: opts.c:808 #, gcc-internal-format msgid "only one -flto-partition value can be specified" msgstr "" -#: opts.c:816 +#: opts.c:819 #, gcc-internal-format msgid "%<-fsplit-stack%> is not supported by this compiler configuration" msgstr "" -#: opts.c:1193 +#: opts.c:1196 #, gcc-internal-format msgid "unrecognized include_flags 0x%x passed to print_specific_help" msgstr "" -#: opts.c:1373 +#: opts.c:1376 #, gcc-internal-format msgid "--help argument %q.*s is ambiguous, please be more specific" msgstr "" -#: opts.c:1382 +#: opts.c:1385 #, gcc-internal-format msgid "unrecognized argument to --help= option: %q.*s" msgstr "" -#: opts.c:1547 +#: opts.c:1550 #, gcc-internal-format, gfc-internal-format msgid "structure alignment must be a small power of two, not %d" msgstr "" -#: opts.c:1664 +#: opts.c:1667 #, gcc-internal-format, gfc-internal-format msgid "unknown stack check parameter \"%s\"" msgstr "" -#: opts.c:1701 +#: opts.c:1704 #, gcc-internal-format, gfc-internal-format msgid "dwarf version %d is not supported" msgstr "" -#: opts.c:1791 +#: opts.c:1794 #, gcc-internal-format, gfc-internal-format msgid "%s: --param arguments should be of the form NAME=VALUE" msgstr "" -#: opts.c:1797 +#: opts.c:1800 #, gcc-internal-format msgid "invalid --param value %qs" msgstr "" -#: opts.c:1915 +#: opts.c:1918 #, gcc-internal-format msgid "target system does not support debug output" msgstr "" -#: opts.c:1924 +#: opts.c:1927 #, gcc-internal-format, gfc-internal-format msgid "debug format \"%s\" conflicts with prior selection" msgstr "" -#: opts.c:1940 +#: opts.c:1943 #, gcc-internal-format, gfc-internal-format msgid "unrecognised debug output level \"%s\"" msgstr "" -#: opts.c:1942 +#: opts.c:1945 #, gcc-internal-format, gfc-internal-format msgid "debug output level %s is too high" msgstr "" -#: opts.c:1962 +#: opts.c:1965 #, gcc-internal-format msgid "getting core file size maximum limit: %m" msgstr "" -#: opts.c:1965 +#: opts.c:1968 #, gcc-internal-format msgid "setting core file size limit to maximum: %m" msgstr "" -#: opts.c:2010 +#: opts.c:2013 #, gcc-internal-format, gfc-internal-format msgid "unrecognized gcc debugging option: %c" msgstr "" -#: opts.c:2036 +#: opts.c:2039 #, gcc-internal-format, gfc-internal-format msgid "-Werror=%s: no option -%s" msgstr "" @@ -15939,8 +15957,8 @@ msgid "can%'t use %qs as a fixed register" msgstr "" #: reginfo.c:750 config/ia64/ia64.c:5897 config/ia64/ia64.c:5904 -#: config/pa/pa.c:428 config/pa/pa.c:435 config/sh/sh.c:9362 -#: config/sh/sh.c:9369 config/spu/spu.c:4908 config/spu/spu.c:4915 +#: config/pa/pa.c:428 config/pa/pa.c:435 config/sh/sh.c:9359 +#: config/sh/sh.c:9366 config/spu/spu.c:4908 config/spu/spu.c:4915 #, gcc-internal-format, gfc-internal-format msgid "unknown register name: %s" msgstr "" @@ -16020,47 +16038,47 @@ msgstr "" msgid "output operand is constant in %<asm%>" msgstr "" -#: rtl.c:738 +#: rtl.c:742 #, gcc-internal-format, gfc-internal-format msgid "RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d" msgstr "" -#: rtl.c:748 +#: rtl.c:752 #, gcc-internal-format, gfc-internal-format msgid "" "RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d" msgstr "" -#: rtl.c:758 +#: rtl.c:762 #, gcc-internal-format, gfc-internal-format msgid "" "RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at " "%s:%d" msgstr "" -#: rtl.c:767 +#: rtl.c:771 #, gcc-internal-format, gfc-internal-format msgid "RTL check: expected code '%s', have '%s' in %s, at %s:%d" msgstr "" -#: rtl.c:777 +#: rtl.c:781 #, gcc-internal-format, gfc-internal-format msgid "RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d" msgstr "" -#: rtl.c:804 +#: rtl.c:808 #, gcc-internal-format, gfc-internal-format msgid "" "RTL check: attempt to treat non-block symbol as a block symbol in %s, at %s:" "%d" msgstr "" -#: rtl.c:814 +#: rtl.c:818 #, gcc-internal-format, gfc-internal-format msgid "RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d" msgstr "" -#: rtl.c:825 +#: rtl.c:829 #, gcc-internal-format, gfc-internal-format msgid "RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d" msgstr "" @@ -16525,7 +16543,7 @@ msgid "" "or %<transaction_may_cancel_outer%>" msgstr "" -#: trans-mem.c:676 trans-mem.c:4569 +#: trans-mem.c:676 trans-mem.c:4570 #, gcc-internal-format msgid "unsafe function call %qD within atomic transaction" msgstr "" @@ -16540,7 +16558,7 @@ msgstr "" msgid "unsafe indirect function call within atomic transaction" msgstr "" -#: trans-mem.c:694 trans-mem.c:4502 +#: trans-mem.c:694 trans-mem.c:4503 #, gcc-internal-format msgid "unsafe function call %qD within %<transaction_safe%> function" msgstr "" @@ -16555,7 +16573,7 @@ msgstr "" msgid "unsafe indirect function call within %<transaction_safe%> function" msgstr "" -#: trans-mem.c:719 trans-mem.c:4541 +#: trans-mem.c:719 trans-mem.c:4542 #, gcc-internal-format msgid "asm not allowed in atomic transaction" msgstr "" @@ -16590,7 +16608,7 @@ msgstr "" msgid "outer transaction in %<transaction_safe%> function" msgstr "" -#: trans-mem.c:4169 +#: trans-mem.c:4170 #, gcc-internal-format msgid "%Kasm not allowed in %<transaction_safe%> function" msgstr "" @@ -16640,7 +16658,7 @@ msgstr "" msgid "MODIFY_EXPR not expected while having tuples" msgstr "" -#: tree-cfg.c:2613 tree-ssa.c:879 +#: tree-cfg.c:2613 tree-ssa.c:876 #, gcc-internal-format msgid "address taken, but ADDRESSABLE bit not set" msgstr "" @@ -17131,7 +17149,7 @@ msgstr "" msgid "incompatible types in PHI argument %u" msgstr "" -#: tree-cfg.c:4433 tree-cfg.c:4727 +#: tree-cfg.c:4433 tree-cfg.c:4738 #, gcc-internal-format msgid "verify_gimple failed" msgstr "" @@ -17146,143 +17164,143 @@ msgstr "" msgid "location references block not in block tree" msgstr "" -#: tree-cfg.c:4594 +#: tree-cfg.c:4605 #, gcc-internal-format msgid "gimple_bb (phi) is set to a wrong basic block" msgstr "" -#: tree-cfg.c:4603 +#: tree-cfg.c:4614 #, gcc-internal-format msgid "PHI node with location" msgstr "" -#: tree-cfg.c:4614 tree-cfg.c:4663 +#: tree-cfg.c:4625 tree-cfg.c:4674 #, gcc-internal-format msgid "incorrect sharing of tree nodes" msgstr "" -#: tree-cfg.c:4622 +#: tree-cfg.c:4633 #, gcc-internal-format msgid "virtual PHI with argument locations" msgstr "" -#: tree-cfg.c:4651 +#: tree-cfg.c:4662 #, gcc-internal-format msgid "gimple_bb (stmt) is set to a wrong basic block" msgstr "" -#: tree-cfg.c:4687 +#: tree-cfg.c:4698 #, gcc-internal-format msgid "in statement" msgstr "" -#: tree-cfg.c:4702 +#: tree-cfg.c:4713 #, gcc-internal-format msgid "statement marked for throw, but doesn%'t" msgstr "" -#: tree-cfg.c:4709 +#: tree-cfg.c:4720 #, gcc-internal-format msgid "statement marked for throw in middle of block" msgstr "" -#: tree-cfg.c:4751 +#: tree-cfg.c:4762 #, gcc-internal-format msgid "ENTRY_BLOCK has IL associated with it" msgstr "" -#: tree-cfg.c:4757 +#: tree-cfg.c:4768 #, gcc-internal-format msgid "EXIT_BLOCK has IL associated with it" msgstr "" -#: tree-cfg.c:4764 +#: tree-cfg.c:4775 #, gcc-internal-format, gfc-internal-format msgid "fallthru to exit from bb %d" msgstr "" -#: tree-cfg.c:4788 +#: tree-cfg.c:4799 #, gcc-internal-format msgid "nonlocal label " msgstr "" -#: tree-cfg.c:4797 +#: tree-cfg.c:4808 #, gcc-internal-format msgid "EH landing pad label " msgstr "" -#: tree-cfg.c:4806 tree-cfg.c:4815 tree-cfg.c:4840 +#: tree-cfg.c:4817 tree-cfg.c:4826 tree-cfg.c:4851 #, gcc-internal-format msgid "label " msgstr "" -#: tree-cfg.c:4830 +#: tree-cfg.c:4841 #, gcc-internal-format, gfc-internal-format msgid "control flow in the middle of basic block %d" msgstr "" -#: tree-cfg.c:4863 +#: tree-cfg.c:4874 #, gcc-internal-format, gfc-internal-format msgid "fallthru edge after a control statement in bb %d" msgstr "" -#: tree-cfg.c:4876 +#: tree-cfg.c:4887 #, gcc-internal-format, gfc-internal-format msgid "true/false edge after a non-GIMPLE_COND in bb %d" msgstr "" -#: tree-cfg.c:4899 tree-cfg.c:4921 tree-cfg.c:4938 tree-cfg.c:5007 +#: tree-cfg.c:4910 tree-cfg.c:4932 tree-cfg.c:4949 tree-cfg.c:5018 #, gcc-internal-format, gfc-internal-format msgid "wrong outgoing edge flags at end of bb %d" msgstr "" -#: tree-cfg.c:4909 +#: tree-cfg.c:4920 #, gcc-internal-format, gfc-internal-format msgid "explicit goto at end of bb %d" msgstr "" -#: tree-cfg.c:4943 +#: tree-cfg.c:4954 #, gcc-internal-format, gfc-internal-format msgid "return edge does not point to exit in bb %d" msgstr "" -#: tree-cfg.c:4973 +#: tree-cfg.c:4984 #, gcc-internal-format msgid "found default case not at the start of case vector" msgstr "" -#: tree-cfg.c:4981 +#: tree-cfg.c:4992 #, gcc-internal-format msgid "case labels not sorted: " msgstr "" -#: tree-cfg.c:4998 +#: tree-cfg.c:5009 #, gcc-internal-format, gfc-internal-format msgid "extra outgoing edge %d->%d" msgstr "" -#: tree-cfg.c:5021 +#: tree-cfg.c:5032 #, gcc-internal-format, gfc-internal-format msgid "missing edge %i->%i" msgstr "" -#: tree-cfg.c:7803 +#: tree-cfg.c:7814 #, gcc-internal-format msgid "%<noreturn%> function does return" msgstr "" -#: tree-cfg.c:7823 +#: tree-cfg.c:7834 #, gcc-internal-format msgid "control reaches end of non-void function" msgstr "" -#: tree-cfg.c:7963 +#: tree-cfg.c:7974 #, gcc-internal-format msgid "" "ignoring return value of %qD, declared with attribute warn_unused_result" msgstr "" -#: tree-cfg.c:7968 +#: tree-cfg.c:7979 #, gcc-internal-format msgid "" "ignoring return value of function declared with attribute warn_unused_result" @@ -17298,134 +17316,134 @@ msgstr "" msgid "in expansion of macro %qs" msgstr "" -#: tree-eh.c:4368 +#: tree-eh.c:4396 #, gcc-internal-format, gfc-internal-format msgid "BB %i has multiple EH edges" msgstr "" -#: tree-eh.c:4380 +#: tree-eh.c:4408 #, gcc-internal-format, gfc-internal-format msgid "BB %i can not throw but has an EH edge" msgstr "" -#: tree-eh.c:4388 +#: tree-eh.c:4416 #, gcc-internal-format, gfc-internal-format msgid "BB %i last statement has incorrectly set lp" msgstr "" -#: tree-eh.c:4394 +#: tree-eh.c:4422 #, gcc-internal-format, gfc-internal-format msgid "BB %i is missing an EH edge" msgstr "" -#: tree-eh.c:4400 +#: tree-eh.c:4428 #, gcc-internal-format, gfc-internal-format msgid "Incorrect EH edge %i->%i" msgstr "" -#: tree-eh.c:4434 tree-eh.c:4453 +#: tree-eh.c:4462 tree-eh.c:4481 #, gcc-internal-format, gfc-internal-format msgid "BB %i is missing an edge" msgstr "" -#: tree-eh.c:4470 +#: tree-eh.c:4498 #, gcc-internal-format, gfc-internal-format msgid "BB %i too many fallthru edges" msgstr "" -#: tree-eh.c:4479 +#: tree-eh.c:4507 #, gcc-internal-format, gfc-internal-format msgid "BB %i has incorrect edge" msgstr "" -#: tree-eh.c:4485 +#: tree-eh.c:4513 #, gcc-internal-format, gfc-internal-format msgid "BB %i has incorrect fallthru edge" msgstr "" -#: tree-inline.c:3012 +#: tree-inline.c:3022 #, gcc-internal-format msgid "function %q+F can never be copied because it receives a non-local goto" msgstr "" -#: tree-inline.c:3026 +#: tree-inline.c:3036 #, gcc-internal-format msgid "" "function %q+F can never be copied because it saves address of local label in " "a static variable" msgstr "" -#: tree-inline.c:3066 +#: tree-inline.c:3076 #, gcc-internal-format msgid "" "function %q+F can never be inlined because it uses alloca (override using " "the always_inline attribute)" msgstr "" -#: tree-inline.c:3080 +#: tree-inline.c:3090 #, gcc-internal-format msgid "function %q+F can never be inlined because it uses setjmp" msgstr "" -#: tree-inline.c:3094 +#: tree-inline.c:3104 #, gcc-internal-format msgid "" "function %q+F can never be inlined because it uses variable argument lists" msgstr "" -#: tree-inline.c:3106 +#: tree-inline.c:3116 #, gcc-internal-format msgid "" "function %q+F can never be inlined because it uses setjmp-longjmp exception " "handling" msgstr "" -#: tree-inline.c:3114 +#: tree-inline.c:3124 #, gcc-internal-format msgid "function %q+F can never be inlined because it uses non-local goto" msgstr "" -#: tree-inline.c:3126 +#: tree-inline.c:3136 #, gcc-internal-format msgid "" "function %q+F can never be inlined because it uses __builtin_return or " "__builtin_apply_args" msgstr "" -#: tree-inline.c:3146 +#: tree-inline.c:3156 #, gcc-internal-format msgid "function %q+F can never be inlined because it contains a computed goto" msgstr "" -#: tree-inline.c:3249 +#: tree-inline.c:3259 #, gcc-internal-format msgid "" "function %q+F can never be inlined because it is suppressed using -fno-inline" msgstr "" -#: tree-inline.c:3257 +#: tree-inline.c:3267 #, gcc-internal-format msgid "" "function %q+F can never be inlined because it uses attributes conflicting " "with inlining" msgstr "" -#: tree-inline.c:3842 +#: tree-inline.c:3852 #, gcc-internal-format msgid "inlining failed in call to always_inline %q+F: %s" msgstr "" -#: tree-inline.c:3844 tree-inline.c:3859 +#: tree-inline.c:3854 tree-inline.c:3869 #, gcc-internal-format msgid "called from here" msgstr "" -#: tree-inline.c:3857 +#: tree-inline.c:3867 #, gcc-internal-format msgid "inlining failed in call to %q+F: %s" msgstr "" -#: tree-into-ssa.c:3209 tree-outof-ssa.c:774 tree-outof-ssa.c:831 +#: tree-into-ssa.c:3226 tree-outof-ssa.c:774 tree-outof-ssa.c:831 #: tree-ssa-coalesce.c:934 tree-ssa-live.c:1282 #, gcc-internal-format msgid "SSA corruption" @@ -17456,6 +17474,16 @@ msgstr "" msgid "unimplemented functionality" msgstr "" +#: tree-ssa-loop-niter.c:2557 +#, gcc-internal-format +msgid "iteration %E invokes undefined behavior" +msgstr "" + +#: tree-ssa-loop-niter.c:2559 +#, gcc-internal-format +msgid "containing loop" +msgstr "" + #: tree-ssa-operands.c:975 #, gcc-internal-format msgid "virtual definition of statement not up-to-date" @@ -17491,142 +17519,142 @@ msgstr "" msgid "stmt volatile flag not up-to-date" msgstr "" -#: tree-ssa-uninit.c:1943 tree-ssa.c:1668 +#: tree-ssa-uninit.c:1946 tree-ssa.c:1665 #, gcc-internal-format msgid "%qD may be used uninitialized in this function" msgstr "" -#: tree-ssa.c:625 +#: tree-ssa.c:622 #, gcc-internal-format msgid "expected an SSA_NAME object" msgstr "" -#: tree-ssa.c:631 +#: tree-ssa.c:628 #, gcc-internal-format msgid "found an SSA_NAME that had been released into the free pool" msgstr "" -#: tree-ssa.c:638 +#: tree-ssa.c:635 #, gcc-internal-format msgid "type mismatch between an SSA_NAME and its symbol" msgstr "" -#: tree-ssa.c:644 +#: tree-ssa.c:641 #, gcc-internal-format msgid "found a virtual definition for a GIMPLE register" msgstr "" -#: tree-ssa.c:650 +#: tree-ssa.c:647 #, gcc-internal-format msgid "virtual SSA name for non-VOP decl" msgstr "" -#: tree-ssa.c:656 +#: tree-ssa.c:653 #, gcc-internal-format msgid "found a real definition for a non-register" msgstr "" -#: tree-ssa.c:663 +#: tree-ssa.c:660 #, gcc-internal-format msgid "found a default name with a non-empty defining statement" msgstr "" -#: tree-ssa.c:693 +#: tree-ssa.c:690 #, gcc-internal-format msgid "RESULT_DECL should be read only when DECL_BY_REFERENCE is set" msgstr "" -#: tree-ssa.c:699 +#: tree-ssa.c:696 #, gcc-internal-format, gfc-internal-format msgid "SSA_NAME created in two different blocks %i and %i" msgstr "" -#: tree-ssa.c:708 tree-ssa.c:1020 +#: tree-ssa.c:705 tree-ssa.c:1017 #, gcc-internal-format msgid "SSA_NAME_DEF_STMT is wrong" msgstr "" -#: tree-ssa.c:760 +#: tree-ssa.c:757 #, gcc-internal-format msgid "missing definition" msgstr "" -#: tree-ssa.c:766 +#: tree-ssa.c:763 #, gcc-internal-format, gfc-internal-format msgid "definition in block %i does not dominate use in block %i" msgstr "" -#: tree-ssa.c:774 +#: tree-ssa.c:771 #, gcc-internal-format, gfc-internal-format msgid "definition in block %i follows the use" msgstr "" -#: tree-ssa.c:781 +#: tree-ssa.c:778 #, gcc-internal-format msgid "SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set" msgstr "" -#: tree-ssa.c:789 +#: tree-ssa.c:786 #, gcc-internal-format msgid "no immediate_use list" msgstr "" -#: tree-ssa.c:801 +#: tree-ssa.c:798 #, gcc-internal-format msgid "wrong immediate use list" msgstr "" -#: tree-ssa.c:835 +#: tree-ssa.c:832 #, gcc-internal-format msgid "incoming edge count does not match number of PHI arguments" msgstr "" -#: tree-ssa.c:849 +#: tree-ssa.c:846 #, gcc-internal-format, gfc-internal-format msgid "PHI argument is missing for edge %d->%d" msgstr "" -#: tree-ssa.c:858 +#: tree-ssa.c:855 #, gcc-internal-format msgid "PHI argument is not SSA_NAME, or invariant" msgstr "" -#: tree-ssa.c:886 +#: tree-ssa.c:883 #, gcc-internal-format, gfc-internal-format msgid "wrong edge %d->%d for PHI argument" msgstr "" -#: tree-ssa.c:967 +#: tree-ssa.c:964 #, gcc-internal-format, gfc-internal-format msgid "AUX pointer initialized for edge %d->%d" msgstr "" -#: tree-ssa.c:992 +#: tree-ssa.c:989 #, gcc-internal-format msgid "stmt (%p) marked modified after optimization pass: " msgstr "" -#: tree-ssa.c:1049 +#: tree-ssa.c:1046 #, gcc-internal-format msgid "verify_ssa failed" msgstr "" -#: tree-ssa.c:1631 varasm.c:322 +#: tree-ssa.c:1628 varasm.c:321 #, gcc-internal-format msgid "%qD was declared here" msgstr "" -#: tree-ssa.c:1663 +#: tree-ssa.c:1660 #, gcc-internal-format msgid "%qD is used uninitialized in this function" msgstr "" -#: tree-ssa.c:1700 +#: tree-ssa.c:1697 #, gcc-internal-format msgid "%qE is used uninitialized in this function" msgstr "" -#: tree-ssa.c:1705 +#: tree-ssa.c:1702 #, gcc-internal-format msgid "%qE may be used uninitialized in this function" msgstr "" @@ -17756,24 +17784,24 @@ msgstr "" msgid "%q+D redeclared without dllimport attribute: previous dllimport ignored" msgstr "" -#: tree.c:5610 tree.c:5622 tree.c:5632 c-family/c-common.c:6380 -#: c-family/c-common.c:6399 c-family/c-common.c:6417 c-family/c-common.c:6445 -#: c-family/c-common.c:6473 c-family/c-common.c:6501 c-family/c-common.c:6517 -#: c-family/c-common.c:6536 c-family/c-common.c:6553 c-family/c-common.c:6577 -#: c-family/c-common.c:6600 c-family/c-common.c:6617 c-family/c-common.c:6645 -#: c-family/c-common.c:6666 c-family/c-common.c:6687 c-family/c-common.c:6714 -#: c-family/c-common.c:6745 c-family/c-common.c:6782 c-family/c-common.c:6809 -#: c-family/c-common.c:6869 c-family/c-common.c:6954 c-family/c-common.c:6984 -#: c-family/c-common.c:7038 c-family/c-common.c:7496 c-family/c-common.c:7514 -#: c-family/c-common.c:7576 c-family/c-common.c:7619 c-family/c-common.c:7690 -#: c-family/c-common.c:7818 c-family/c-common.c:7886 c-family/c-common.c:7944 -#: c-family/c-common.c:7992 c-family/c-common.c:8155 c-family/c-common.c:8176 -#: c-family/c-common.c:8288 c-family/c-common.c:8312 c-family/c-common.c:8619 -#: c-family/c-common.c:8642 c-family/c-common.c:8681 c-family/c-common.c:8759 -#: c-family/c-common.c:8906 config/darwin.c:1997 config/arm/arm.c:5119 -#: config/arm/arm.c:5147 config/arm/arm.c:5164 config/avr/avr.c:7789 -#: config/h8300/h8300.c:5463 config/h8300/h8300.c:5487 config/i386/i386.c:4965 -#: config/i386/i386.c:34737 config/ia64/ia64.c:737 +#: tree.c:5610 tree.c:5622 tree.c:5632 c-family/c-common.c:6385 +#: c-family/c-common.c:6404 c-family/c-common.c:6422 c-family/c-common.c:6450 +#: c-family/c-common.c:6478 c-family/c-common.c:6506 c-family/c-common.c:6522 +#: c-family/c-common.c:6537 c-family/c-common.c:6558 c-family/c-common.c:6575 +#: c-family/c-common.c:6599 c-family/c-common.c:6622 c-family/c-common.c:6639 +#: c-family/c-common.c:6667 c-family/c-common.c:6688 c-family/c-common.c:6709 +#: c-family/c-common.c:6736 c-family/c-common.c:6767 c-family/c-common.c:6804 +#: c-family/c-common.c:6831 c-family/c-common.c:6891 c-family/c-common.c:6976 +#: c-family/c-common.c:7006 c-family/c-common.c:7060 c-family/c-common.c:7518 +#: c-family/c-common.c:7536 c-family/c-common.c:7598 c-family/c-common.c:7641 +#: c-family/c-common.c:7712 c-family/c-common.c:7840 c-family/c-common.c:7908 +#: c-family/c-common.c:7966 c-family/c-common.c:8014 c-family/c-common.c:8177 +#: c-family/c-common.c:8198 c-family/c-common.c:8310 c-family/c-common.c:8334 +#: c-family/c-common.c:8641 c-family/c-common.c:8664 c-family/c-common.c:8703 +#: c-family/c-common.c:8781 c-family/c-common.c:8928 config/darwin.c:1997 +#: config/arm/arm.c:5119 config/arm/arm.c:5147 config/arm/arm.c:5164 +#: config/avr/avr.c:7789 config/h8300/h8300.c:5463 config/h8300/h8300.c:5487 +#: config/i386/i386.c:4965 config/i386/i386.c:34737 config/ia64/ia64.c:737 #: config/rs6000/rs6000.c:24907 config/spu/spu.c:3743 #: ada/gcc-interface/utils.c:6189 lto/lto-lang.c:222 #, gcc-internal-format @@ -17969,142 +17997,142 @@ msgstr "" msgid "variable tracking size limit exceeded" msgstr "" -#: varasm.c:315 +#: varasm.c:314 #, gcc-internal-format msgid "%+D causes a section type conflict" msgstr "" -#: varasm.c:318 +#: varasm.c:317 #, gcc-internal-format msgid "%+D causes a section type conflict with %D" msgstr "" -#: varasm.c:960 +#: varasm.c:959 #, gcc-internal-format msgid "" "alignment of %q+D is greater than maximum object file alignment. Using %d" msgstr "" -#: varasm.c:1200 varasm.c:1209 +#: varasm.c:1198 varasm.c:1207 #, gcc-internal-format msgid "register name not specified for %q+D" msgstr "" -#: varasm.c:1211 +#: varasm.c:1209 #, gcc-internal-format msgid "invalid register name for %q+D" msgstr "" -#: varasm.c:1213 +#: varasm.c:1211 #, gcc-internal-format msgid "data type of %q+D isn%'t suitable for a register" msgstr "" -#: varasm.c:1216 +#: varasm.c:1214 #, gcc-internal-format msgid "" "the register specified for %q+D cannot be accessed by the current target" msgstr "" -#: varasm.c:1219 +#: varasm.c:1217 #, gcc-internal-format msgid "" "the register specified for %q+D is not general enough to be used as a " "register variable" msgstr "" -#: varasm.c:1222 +#: varasm.c:1220 #, gcc-internal-format msgid "register specified for %q+D isn%'t suitable for data type" msgstr "" -#: varasm.c:1232 +#: varasm.c:1230 #, gcc-internal-format msgid "global register variable has initial value" msgstr "" -#: varasm.c:1236 +#: varasm.c:1234 #, gcc-internal-format msgid "optimization may eliminate reads and/or writes to register variables" msgstr "" -#: varasm.c:1274 +#: varasm.c:1272 #, gcc-internal-format msgid "register name given for non-register variable %q+D" msgstr "" -#: varasm.c:1820 +#: varasm.c:1818 #, gcc-internal-format msgid "thread-local COMMON data not implemented" msgstr "" -#: varasm.c:1852 +#: varasm.c:1850 #, gcc-internal-format msgid "" "requested alignment for %q+D is greater than implemented alignment of %wu" msgstr "" -#: varasm.c:1940 c/c-decl.c:4353 +#: varasm.c:1938 c/c-decl.c:4353 #, gcc-internal-format msgid "storage size of %q+D isn%'t known" msgstr "" -#: varasm.c:4605 +#: varasm.c:4590 #, gcc-internal-format msgid "initializer for integer/fixed-point value is too complicated" msgstr "" -#: varasm.c:4610 +#: varasm.c:4595 #, gcc-internal-format msgid "initializer for floating value is not a floating constant" msgstr "" -#: varasm.c:4918 +#: varasm.c:4903 #, gcc-internal-format msgid "invalid initial value for member %qE" msgstr "" -#: varasm.c:5270 +#: varasm.c:5255 #, gcc-internal-format msgid "weak declaration of %q+D must be public" msgstr "" -#: varasm.c:5272 +#: varasm.c:5257 #, gcc-internal-format msgid "weak declaration of %q+D not supported" msgstr "" -#: varasm.c:5301 varasm.c:5598 +#: varasm.c:5286 varasm.c:5583 #, gcc-internal-format msgid "only weak aliases are supported in this configuration" msgstr "" -#: varasm.c:5490 +#: varasm.c:5475 #, gcc-internal-format msgid "weakref is not supported in this configuration" msgstr "" -#: varasm.c:5513 varasm.c:5595 +#: varasm.c:5498 varasm.c:5580 #, gcc-internal-format msgid "ifunc is not supported in this configuration" msgstr "" -#: varasm.c:5572 +#: varasm.c:5557 #, gcc-internal-format msgid "weakref %q+D ultimately targets itself" msgstr "" -#: varasm.c:5581 +#: varasm.c:5566 #, gcc-internal-format msgid "weakref %q+D must have static linkage" msgstr "" -#: varasm.c:5588 +#: varasm.c:5573 #, gcc-internal-format msgid "alias definitions not supported in this configuration" msgstr "" -#: varasm.c:5807 config/sol2.c:155 config/i386/winnt.c:254 +#: varasm.c:5792 config/sol2.c:155 config/i386/winnt.c:254 #, gcc-internal-format msgid "visibility attribute not supported in this configuration; ignored" msgstr "" @@ -18130,1368 +18158,1368 @@ msgstr "" msgid "bytecode stream: tag %s is not in the expected range [%s, %s]" msgstr "" -#: c-family/c-common.c:911 +#: c-family/c-common.c:916 #, gcc-internal-format msgid "%qD is not defined outside of function scope" msgstr "" -#: c-family/c-common.c:961 +#: c-family/c-common.c:966 #, gcc-internal-format msgid "" "string length %qd is greater than the length %qd ISO C%d compilers are " "required to support" msgstr "" -#: c-family/c-common.c:1280 c/c-typeck.c:9864 cp/typeck.c:4158 +#: c-family/c-common.c:1285 c/c-typeck.c:9864 cp/typeck.c:4158 #, gcc-internal-format msgid "left shift count is negative" msgstr "" -#: c-family/c-common.c:1281 c/c-typeck.c:9812 cp/typeck.c:4112 +#: c-family/c-common.c:1286 c/c-typeck.c:9812 cp/typeck.c:4112 #, gcc-internal-format msgid "right shift count is negative" msgstr "" -#: c-family/c-common.c:1286 c/c-typeck.c:9871 cp/typeck.c:4165 +#: c-family/c-common.c:1291 c/c-typeck.c:9871 cp/typeck.c:4165 #, gcc-internal-format msgid "left shift count >= width of type" msgstr "" -#: c-family/c-common.c:1287 c/c-typeck.c:9823 cp/typeck.c:4119 +#: c-family/c-common.c:1292 c/c-typeck.c:9823 cp/typeck.c:4119 #, gcc-internal-format msgid "right shift count >= width of type" msgstr "" -#: c-family/c-common.c:1508 c-family/c-common.c:1520 cp/semantics.c:6865 +#: c-family/c-common.c:1513 c-family/c-common.c:1525 cp/semantics.c:6867 #, gcc-internal-format msgid "overflow in constant expression" msgstr "" -#: c-family/c-common.c:1543 +#: c-family/c-common.c:1548 #, gcc-internal-format msgid "integer overflow in expression" msgstr "" -#: c-family/c-common.c:1548 +#: c-family/c-common.c:1553 #, gcc-internal-format msgid "floating point overflow in expression" msgstr "" -#: c-family/c-common.c:1552 +#: c-family/c-common.c:1557 #, gcc-internal-format msgid "fixed-point overflow in expression" msgstr "" -#: c-family/c-common.c:1556 +#: c-family/c-common.c:1561 #, gcc-internal-format msgid "vector overflow in expression" msgstr "" -#: c-family/c-common.c:1562 +#: c-family/c-common.c:1567 #, gcc-internal-format msgid "complex integer overflow in expression" msgstr "" -#: c-family/c-common.c:1565 +#: c-family/c-common.c:1570 #, gcc-internal-format msgid "complex floating point overflow in expression" msgstr "" -#: c-family/c-common.c:1608 +#: c-family/c-common.c:1613 #, gcc-internal-format msgid "logical %<or%> applied to non-boolean constant" msgstr "" -#: c-family/c-common.c:1611 +#: c-family/c-common.c:1616 #, gcc-internal-format msgid "logical %<and%> applied to non-boolean constant" msgstr "" -#: c-family/c-common.c:1675 +#: c-family/c-common.c:1680 #, gcc-internal-format msgid "logical %<or%> of collectively exhaustive tests is always true" msgstr "" -#: c-family/c-common.c:1679 +#: c-family/c-common.c:1684 #, gcc-internal-format msgid "logical %<and%> of mutually exclusive tests is always false" msgstr "" -#: c-family/c-common.c:1811 +#: c-family/c-common.c:1816 #, gcc-internal-format msgid "type-punning to incomplete type might break strict-aliasing rules" msgstr "" -#: c-family/c-common.c:1826 +#: c-family/c-common.c:1831 #, gcc-internal-format msgid "dereferencing type-punned pointer will break strict-aliasing rules" msgstr "" -#: c-family/c-common.c:1833 c-family/c-common.c:1851 +#: c-family/c-common.c:1838 c-family/c-common.c:1856 #, gcc-internal-format msgid "dereferencing type-punned pointer might break strict-aliasing rules" msgstr "" -#: c-family/c-common.c:1985 +#: c-family/c-common.c:1990 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the " "destination; did you mean to remove the addressof?" msgstr "" -#: c-family/c-common.c:1992 +#: c-family/c-common.c:1997 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the " "destination; did you mean to provide an explicit length?" msgstr "" -#: c-family/c-common.c:1997 +#: c-family/c-common.c:2002 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the " "destination; did you mean to dereference it?" msgstr "" -#: c-family/c-common.c:2009 +#: c-family/c-common.c:2014 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same pointer type %qT as the " "destination; expected %qT or an explicit length" msgstr "" -#: c-family/c-common.c:2025 +#: c-family/c-common.c:2030 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the source; did " "you mean to remove the addressof?" msgstr "" -#: c-family/c-common.c:2032 +#: c-family/c-common.c:2037 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the source; did " "you mean to provide an explicit length?" msgstr "" -#: c-family/c-common.c:2037 +#: c-family/c-common.c:2042 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the source; did " "you mean to dereference it?" msgstr "" -#: c-family/c-common.c:2049 +#: c-family/c-common.c:2054 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same pointer type %qT as the " "source; expected %qT or an explicit length" msgstr "" -#: c-family/c-common.c:2065 +#: c-family/c-common.c:2070 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the first " "source; did you mean to remove the addressof?" msgstr "" -#: c-family/c-common.c:2072 +#: c-family/c-common.c:2077 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the first " "source; did you mean to provide an explicit length?" msgstr "" -#: c-family/c-common.c:2077 +#: c-family/c-common.c:2082 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the first " "source; did you mean to dereference it?" msgstr "" -#: c-family/c-common.c:2089 +#: c-family/c-common.c:2094 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same pointer type %qT as the first " "source; expected %qT or an explicit length" msgstr "" -#: c-family/c-common.c:2105 +#: c-family/c-common.c:2110 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the second " "source; did you mean to remove the addressof?" msgstr "" -#: c-family/c-common.c:2112 +#: c-family/c-common.c:2117 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the second " "source; did you mean to provide an explicit length?" msgstr "" -#: c-family/c-common.c:2117 +#: c-family/c-common.c:2122 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same expression as the second " "source; did you mean to dereference it?" msgstr "" -#: c-family/c-common.c:2129 +#: c-family/c-common.c:2134 #, gcc-internal-format msgid "" "argument to %<sizeof%> in %qD call is the same pointer type %qT as the " "second source; expected %qT or an explicit length" msgstr "" -#: c-family/c-common.c:2161 +#: c-family/c-common.c:2166 #, gcc-internal-format msgid "first argument of %q+D should be %<int%>" msgstr "" -#: c-family/c-common.c:2170 +#: c-family/c-common.c:2175 #, gcc-internal-format msgid "second argument of %q+D should be %<char **%>" msgstr "" -#: c-family/c-common.c:2179 +#: c-family/c-common.c:2184 #, gcc-internal-format msgid "third argument of %q+D should probably be %<char **%>" msgstr "" -#: c-family/c-common.c:2190 +#: c-family/c-common.c:2195 #, gcc-internal-format msgid "%q+D takes only zero or two arguments" msgstr "" -#: c-family/c-common.c:2239 +#: c-family/c-common.c:2244 #, gcc-internal-format msgid "" "use -flax-vector-conversions to permit conversions between vectors with " "differing element types or numbers of subparts" msgstr "" -#: c-family/c-common.c:2278 +#: c-family/c-common.c:2283 #, gcc-internal-format msgid "__builtin_shuffle last argument must be an integer vector" msgstr "" -#: c-family/c-common.c:2286 +#: c-family/c-common.c:2291 #, gcc-internal-format msgid "__builtin_shuffle arguments must be vectors" msgstr "" -#: c-family/c-common.c:2292 +#: c-family/c-common.c:2297 #, gcc-internal-format msgid "__builtin_shuffle argument vectors must be of the same type" msgstr "" -#: c-family/c-common.c:2302 +#: c-family/c-common.c:2307 #, gcc-internal-format msgid "" "__builtin_shuffle number of elements of the argument vector(s) and the mask " "vector should be the same" msgstr "" -#: c-family/c-common.c:2311 +#: c-family/c-common.c:2316 #, gcc-internal-format msgid "" "__builtin_shuffle argument vector(s) inner type must have the same size as " "inner type of the mask" msgstr "" -#: c-family/c-common.c:2505 +#: c-family/c-common.c:2510 #, gcc-internal-format msgid "negative integer implicitly converted to unsigned type" msgstr "" -#: c-family/c-common.c:2511 +#: c-family/c-common.c:2516 #, gcc-internal-format msgid "conversion of unsigned constant value to negative integer" msgstr "" -#: c-family/c-common.c:2605 +#: c-family/c-common.c:2610 #, gcc-internal-format msgid "conversion to %qT from %qT may change the sign of the result" msgstr "" -#: c-family/c-common.c:2674 +#: c-family/c-common.c:2679 #, gcc-internal-format msgid "conversion to %qT from boolean expression" msgstr "" -#: c-family/c-common.c:2681 +#: c-family/c-common.c:2686 #, gcc-internal-format msgid "conversion to %qT alters %qT constant value" msgstr "" -#: c-family/c-common.c:2700 +#: c-family/c-common.c:2705 #, gcc-internal-format msgid "conversion to %qT from %qT may alter its value" msgstr "" -#: c-family/c-common.c:2730 +#: c-family/c-common.c:2735 #, gcc-internal-format msgid "large integer implicitly truncated to unsigned type" msgstr "" -#: c-family/c-common.c:2736 c-family/c-common.c:2743 c-family/c-common.c:2751 +#: c-family/c-common.c:2741 c-family/c-common.c:2748 c-family/c-common.c:2756 #, gcc-internal-format msgid "overflow in implicit constant conversion" msgstr "" -#: c-family/c-common.c:2923 +#: c-family/c-common.c:2928 #, gcc-internal-format msgid "operation on %qE may be undefined" msgstr "" -#: c-family/c-common.c:3234 +#: c-family/c-common.c:3239 #, gcc-internal-format msgid "case label does not reduce to an integer constant" msgstr "" -#: c-family/c-common.c:3274 +#: c-family/c-common.c:3279 #, gcc-internal-format msgid "case label value is less than minimum value for type" msgstr "" -#: c-family/c-common.c:3282 +#: c-family/c-common.c:3287 #, gcc-internal-format msgid "case label value exceeds maximum value for type" msgstr "" -#: c-family/c-common.c:3290 +#: c-family/c-common.c:3295 #, gcc-internal-format msgid "lower value in case label range less than minimum value for type" msgstr "" -#: c-family/c-common.c:3299 +#: c-family/c-common.c:3304 #, gcc-internal-format msgid "upper value in case label range exceeds maximum value for type" msgstr "" -#: c-family/c-common.c:3378 +#: c-family/c-common.c:3383 #, gcc-internal-format msgid "" "GCC cannot support operators with integer types and fixed-point types that " "have too many integral and fractional bits together" msgstr "" -#: c-family/c-common.c:3881 +#: c-family/c-common.c:3886 #, gcc-internal-format msgid "invalid operands to binary %s (have %qT and %qT)" msgstr "" -#: c-family/c-common.c:4142 +#: c-family/c-common.c:4147 #, gcc-internal-format msgid "comparison is always false due to limited range of data type" msgstr "" -#: c-family/c-common.c:4145 +#: c-family/c-common.c:4150 #, gcc-internal-format msgid "comparison is always true due to limited range of data type" msgstr "" -#: c-family/c-common.c:4230 +#: c-family/c-common.c:4235 #, gcc-internal-format msgid "comparison of unsigned expression >= 0 is always true" msgstr "" -#: c-family/c-common.c:4237 +#: c-family/c-common.c:4242 #, gcc-internal-format msgid "comparison of unsigned expression < 0 is always false" msgstr "" -#: c-family/c-common.c:4279 +#: c-family/c-common.c:4284 #, gcc-internal-format msgid "pointer of type %<void *%> used in arithmetic" msgstr "" -#: c-family/c-common.c:4285 +#: c-family/c-common.c:4290 #, gcc-internal-format msgid "pointer to a function used in arithmetic" msgstr "" -#: c-family/c-common.c:4291 +#: c-family/c-common.c:4296 #, gcc-internal-format msgid "pointer to member function used in arithmetic" msgstr "" -#: c-family/c-common.c:4503 +#: c-family/c-common.c:4508 #, gcc-internal-format msgid "the address of %qD will always evaluate as %<true%>" msgstr "" -#: c-family/c-common.c:4598 cp/semantics.c:592 cp/typeck.c:7906 +#: c-family/c-common.c:4603 cp/semantics.c:592 cp/typeck.c:7906 #, gcc-internal-format msgid "suggest parentheses around assignment used as truth value" msgstr "" -#: c-family/c-common.c:4677 c/c-decl.c:3686 c/c-typeck.c:10883 +#: c-family/c-common.c:4682 c/c-decl.c:3686 c/c-typeck.c:10883 #, gcc-internal-format msgid "invalid use of %<restrict%>" msgstr "" -#: c-family/c-common.c:4870 +#: c-family/c-common.c:4875 #, gcc-internal-format msgid "invalid application of %<sizeof%> to a function type" msgstr "" -#: c-family/c-common.c:4880 +#: c-family/c-common.c:4885 #, gcc-internal-format msgid "ISO C++ does not permit %<alignof%> applied to a function type" msgstr "" -#: c-family/c-common.c:4883 +#: c-family/c-common.c:4888 #, gcc-internal-format msgid "ISO C does not permit %<_Alignof%> applied to a function type" msgstr "" -#: c-family/c-common.c:4894 +#: c-family/c-common.c:4899 #, gcc-internal-format msgid "invalid application of %qs to a void type" msgstr "" -#: c-family/c-common.c:4903 +#: c-family/c-common.c:4908 #, gcc-internal-format msgid "invalid application of %qs to incomplete type %qT" msgstr "" -#: c-family/c-common.c:4911 +#: c-family/c-common.c:4916 #, gcc-internal-format msgid "invalid application of %qs to array type %qT of incomplete element type" msgstr "" -#: c-family/c-common.c:4951 +#: c-family/c-common.c:4956 #, gcc-internal-format msgid "%<__alignof%> applied to a bit-field" msgstr "" -#: c-family/c-common.c:5664 +#: c-family/c-common.c:5669 #, gcc-internal-format msgid "cannot disable built-in function %qs" msgstr "" -#: c-family/c-common.c:5855 +#: c-family/c-common.c:5860 #, gcc-internal-format msgid "pointers are not permitted as case values" msgstr "" -#: c-family/c-common.c:5862 +#: c-family/c-common.c:5867 #, gcc-internal-format msgid "range expressions in switch statements are non-standard" msgstr "" -#: c-family/c-common.c:5888 +#: c-family/c-common.c:5893 #, gcc-internal-format msgid "empty range specified" msgstr "" -#: c-family/c-common.c:5948 +#: c-family/c-common.c:5953 #, gcc-internal-format msgid "duplicate (or overlapping) case value" msgstr "" -#: c-family/c-common.c:5950 +#: c-family/c-common.c:5955 #, gcc-internal-format msgid "this is the first entry overlapping that value" msgstr "" -#: c-family/c-common.c:5954 +#: c-family/c-common.c:5959 #, gcc-internal-format msgid "duplicate case value" msgstr "" -#: c-family/c-common.c:5955 +#: c-family/c-common.c:5960 #, gcc-internal-format msgid "previously used here" msgstr "" -#: c-family/c-common.c:5959 +#: c-family/c-common.c:5964 #, gcc-internal-format msgid "multiple default labels in one switch" msgstr "" -#: c-family/c-common.c:5961 +#: c-family/c-common.c:5966 #, gcc-internal-format msgid "this is the first default label" msgstr "" -#: c-family/c-common.c:6013 +#: c-family/c-common.c:6018 #, gcc-internal-format msgid "case value %qs not in enumerated type" msgstr "" -#: c-family/c-common.c:6018 +#: c-family/c-common.c:6023 #, gcc-internal-format msgid "case value %qs not in enumerated type %qT" msgstr "" -#: c-family/c-common.c:6077 +#: c-family/c-common.c:6082 #, gcc-internal-format msgid "switch missing default case" msgstr "" -#: c-family/c-common.c:6149 +#: c-family/c-common.c:6154 #, gcc-internal-format msgid "enumeration value %qE not handled in switch" msgstr "" -#: c-family/c-common.c:6175 +#: c-family/c-common.c:6180 #, gcc-internal-format msgid "taking the address of a label is non-standard" msgstr "" -#: c-family/c-common.c:6369 +#: c-family/c-common.c:6374 #, gcc-internal-format msgid "%qE attribute ignored for field of type %qT" msgstr "" -#: c-family/c-common.c:6464 c-family/c-common.c:6492 +#: c-family/c-common.c:6469 c-family/c-common.c:6497 #, gcc-internal-format msgid "%qE attribute conflicts with attribute %s" msgstr "" -#: c-family/c-common.c:6622 lto/lto-lang.c:227 +#: c-family/c-common.c:6644 lto/lto-lang.c:227 #, gcc-internal-format msgid "%qE attribute has no effect on unit local functions" msgstr "" -#: c-family/c-common.c:6776 +#: c-family/c-common.c:6798 #, gcc-internal-format msgid "%qE attribute have effect only on public objects" msgstr "" -#: c-family/c-common.c:6890 +#: c-family/c-common.c:6912 #, gcc-internal-format msgid "destructor priorities are not supported" msgstr "" -#: c-family/c-common.c:6892 +#: c-family/c-common.c:6914 #, gcc-internal-format msgid "constructor priorities are not supported" msgstr "" -#: c-family/c-common.c:6910 +#: c-family/c-common.c:6932 #, gcc-internal-format, gfc-internal-format msgid "destructor priorities from 0 to %d are reserved for the implementation" msgstr "" -#: c-family/c-common.c:6915 +#: c-family/c-common.c:6937 #, gcc-internal-format, gfc-internal-format msgid "constructor priorities from 0 to %d are reserved for the implementation" msgstr "" -#: c-family/c-common.c:6923 +#: c-family/c-common.c:6945 #, gcc-internal-format, gfc-internal-format msgid "destructor priorities must be integers from 0 to %d inclusive" msgstr "" -#: c-family/c-common.c:6926 +#: c-family/c-common.c:6948 #, gcc-internal-format, gfc-internal-format msgid "constructor priorities must be integers from 0 to %d inclusive" msgstr "" -#: c-family/c-common.c:7082 +#: c-family/c-common.c:7104 #, gcc-internal-format msgid "unknown machine mode %qE" msgstr "" -#: c-family/c-common.c:7111 +#: c-family/c-common.c:7133 #, gcc-internal-format msgid "specifying vector types with __attribute__ ((mode)) is deprecated" msgstr "" -#: c-family/c-common.c:7114 +#: c-family/c-common.c:7136 #, gcc-internal-format msgid "use __attribute__ ((vector_size)) instead" msgstr "" -#: c-family/c-common.c:7123 +#: c-family/c-common.c:7145 #, gcc-internal-format msgid "unable to emulate %qs" msgstr "" -#: c-family/c-common.c:7134 +#: c-family/c-common.c:7156 #, gcc-internal-format msgid "invalid pointer mode %qs" msgstr "" -#: c-family/c-common.c:7151 +#: c-family/c-common.c:7173 #, gcc-internal-format msgid "signedness of type and machine mode %qs don%'t match" msgstr "" -#: c-family/c-common.c:7162 +#: c-family/c-common.c:7184 #, gcc-internal-format msgid "no data type for mode %qs" msgstr "" -#: c-family/c-common.c:7172 +#: c-family/c-common.c:7194 #, gcc-internal-format msgid "cannot use mode %qs for enumeral types" msgstr "" -#: c-family/c-common.c:7199 +#: c-family/c-common.c:7221 #, gcc-internal-format msgid "mode %qs applied to inappropriate type" msgstr "" -#: c-family/c-common.c:7231 +#: c-family/c-common.c:7253 #, gcc-internal-format msgid "section attribute cannot be specified for local variables" msgstr "" -#: c-family/c-common.c:7242 config/bfin/bfin.c:4737 config/bfin/bfin.c:4788 +#: c-family/c-common.c:7264 config/bfin/bfin.c:4737 config/bfin/bfin.c:4788 #: config/bfin/bfin.c:4815 config/bfin/bfin.c:4828 #, gcc-internal-format msgid "section of %q+D conflicts with previous declaration" msgstr "" -#: c-family/c-common.c:7250 +#: c-family/c-common.c:7272 #, gcc-internal-format msgid "section of %q+D cannot be overridden" msgstr "" -#: c-family/c-common.c:7258 +#: c-family/c-common.c:7280 #, gcc-internal-format msgid "section attribute not allowed for %q+D" msgstr "" -#: c-family/c-common.c:7265 +#: c-family/c-common.c:7287 #, gcc-internal-format msgid "section attributes are not supported for this target" msgstr "" -#: c-family/c-common.c:7284 +#: c-family/c-common.c:7306 #, gcc-internal-format msgid "requested alignment is not an integer constant" msgstr "" -#: c-family/c-common.c:7291 +#: c-family/c-common.c:7313 #, gcc-internal-format msgid "requested alignment is not a power of 2" msgstr "" -#: c-family/c-common.c:7296 +#: c-family/c-common.c:7318 #, gcc-internal-format msgid "requested alignment is too large" msgstr "" -#: c-family/c-common.c:7379 +#: c-family/c-common.c:7401 #, gcc-internal-format, gfc-internal-format msgid "requested alignment %d is larger than %d" msgstr "" -#: c-family/c-common.c:7436 +#: c-family/c-common.c:7458 #, gcc-internal-format msgid "alignment may not be specified for %q+D" msgstr "" -#: c-family/c-common.c:7454 +#: c-family/c-common.c:7476 #, gcc-internal-format msgid "" "alignment for %q+D was previously specified as %d and may not be decreased" msgstr "" -#: c-family/c-common.c:7458 +#: c-family/c-common.c:7480 #, gcc-internal-format msgid "alignment for %q+D must be at least %d" msgstr "" -#: c-family/c-common.c:7483 +#: c-family/c-common.c:7505 #, gcc-internal-format msgid "inline function %q+D declared weak" msgstr "" -#: c-family/c-common.c:7488 +#: c-family/c-common.c:7510 #, gcc-internal-format msgid "indirect function %q+D cannot be declared weak" msgstr "" -#: c-family/c-common.c:7525 +#: c-family/c-common.c:7547 #, gcc-internal-format msgid "%q+D defined both normally and as %qE attribute" msgstr "" -#: c-family/c-common.c:7533 +#: c-family/c-common.c:7555 #, gcc-internal-format msgid "weak %q+D cannot be defined %qE" msgstr "" -#: c-family/c-common.c:7550 +#: c-family/c-common.c:7572 #, gcc-internal-format msgid "attribute %qE argument not a string" msgstr "" -#: c-family/c-common.c:7626 +#: c-family/c-common.c:7648 #, gcc-internal-format msgid "indirect function %q+D cannot be declared weakref" msgstr "" -#: c-family/c-common.c:7648 +#: c-family/c-common.c:7670 #, gcc-internal-format msgid "weakref attribute must appear before alias attribute" msgstr "" -#: c-family/c-common.c:7677 +#: c-family/c-common.c:7699 #, gcc-internal-format msgid "%qE attribute ignored on non-class types" msgstr "" -#: c-family/c-common.c:7683 +#: c-family/c-common.c:7705 #, gcc-internal-format msgid "%qE attribute ignored because %qT is already defined" msgstr "" -#: c-family/c-common.c:7696 +#: c-family/c-common.c:7718 #, gcc-internal-format msgid "visibility argument not a string" msgstr "" -#: c-family/c-common.c:7708 +#: c-family/c-common.c:7730 #, gcc-internal-format msgid "%qE attribute ignored on types" msgstr "" -#: c-family/c-common.c:7724 +#: c-family/c-common.c:7746 #, gcc-internal-format msgid "" "visibility argument must be one of \"default\", \"hidden\", \"protected\" or " "\"internal\"" msgstr "" -#: c-family/c-common.c:7735 +#: c-family/c-common.c:7757 #, gcc-internal-format msgid "%qD redeclared with different visibility" msgstr "" -#: c-family/c-common.c:7738 c-family/c-common.c:7742 +#: c-family/c-common.c:7760 c-family/c-common.c:7764 #, gcc-internal-format msgid "%qD was declared %qs which implies default visibility" msgstr "" -#: c-family/c-common.c:7826 +#: c-family/c-common.c:7848 #, gcc-internal-format msgid "tls_model argument not a string" msgstr "" -#: c-family/c-common.c:7839 +#: c-family/c-common.c:7861 #, gcc-internal-format msgid "" "tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-" "dynamic\" or \"global-dynamic\"" msgstr "" -#: c-family/c-common.c:7859 c-family/c-common.c:7965 c-family/c-common.c:8950 +#: c-family/c-common.c:7881 c-family/c-common.c:7987 c-family/c-common.c:8970 #: config/m32c/m32c.c:2926 #, gcc-internal-format msgid "%qE attribute applies only to functions" msgstr "" -#: c-family/c-common.c:7865 c-family/c-common.c:7971 c-family/c-common.c:8956 +#: c-family/c-common.c:7887 c-family/c-common.c:7993 c-family/c-common.c:8976 #, gcc-internal-format msgid "can%'t set %qE attribute after definition" msgstr "" -#: c-family/c-common.c:7911 +#: c-family/c-common.c:7933 #, gcc-internal-format msgid "alloc_size parameter outside range" msgstr "" -#: c-family/c-common.c:8029 +#: c-family/c-common.c:8051 #, gcc-internal-format msgid "%qE attribute duplicated" msgstr "" -#: c-family/c-common.c:8031 +#: c-family/c-common.c:8053 #, gcc-internal-format msgid "%qE attribute follows %qE" msgstr "" -#: c-family/c-common.c:8130 +#: c-family/c-common.c:8152 #, gcc-internal-format msgid "type was previously declared %qE" msgstr "" -#: c-family/c-common.c:8183 +#: c-family/c-common.c:8205 #, gcc-internal-format msgid "%qE argument not an identifier" msgstr "" -#: c-family/c-common.c:8194 +#: c-family/c-common.c:8216 #, gcc-internal-format msgid "%qD is not compatible with %qD" msgstr "" -#: c-family/c-common.c:8197 +#: c-family/c-common.c:8219 #, gcc-internal-format msgid "transaction_wrap argument is not a function" msgstr "" -#: c-family/c-common.c:8245 +#: c-family/c-common.c:8267 #, gcc-internal-format msgid "deprecated message is not a string" msgstr "" -#: c-family/c-common.c:8286 +#: c-family/c-common.c:8308 #, gcc-internal-format msgid "%qE attribute ignored for %qE" msgstr "" -#: c-family/c-common.c:8346 +#: c-family/c-common.c:8368 #, gcc-internal-format msgid "invalid vector type for attribute %qE" msgstr "" -#: c-family/c-common.c:8352 ada/gcc-interface/utils.c:6307 +#: c-family/c-common.c:8374 ada/gcc-interface/utils.c:6307 #: ada/gcc-interface/utils.c:6401 #, gcc-internal-format msgid "vector size not an integral multiple of component size" msgstr "" -#: c-family/c-common.c:8358 ada/gcc-interface/utils.c:6313 +#: c-family/c-common.c:8380 ada/gcc-interface/utils.c:6313 #: ada/gcc-interface/utils.c:6407 #, gcc-internal-format msgid "zero vector size" msgstr "" -#: c-family/c-common.c:8366 ada/gcc-interface/utils.c:6321 +#: c-family/c-common.c:8388 ada/gcc-interface/utils.c:6321 #: ada/gcc-interface/utils.c:6414 #, gcc-internal-format msgid "number of components of the vector not a power of two" msgstr "" -#: c-family/c-common.c:8394 ada/gcc-interface/utils.c:6048 +#: c-family/c-common.c:8416 ada/gcc-interface/utils.c:6048 #, gcc-internal-format msgid "nonnull attribute without arguments on a non-prototype" msgstr "" -#: c-family/c-common.c:8408 ada/gcc-interface/utils.c:6062 +#: c-family/c-common.c:8430 ada/gcc-interface/utils.c:6062 #, gcc-internal-format, gfc-internal-format msgid "nonnull argument has invalid operand number (argument %lu)" msgstr "" -#: c-family/c-common.c:8430 ada/gcc-interface/utils.c:6084 +#: c-family/c-common.c:8452 ada/gcc-interface/utils.c:6084 #, gcc-internal-format, gfc-internal-format msgid "" "nonnull argument with out-of-range operand number (argument %lu, operand %lu)" msgstr "" -#: c-family/c-common.c:8438 ada/gcc-interface/utils.c:6093 +#: c-family/c-common.c:8460 ada/gcc-interface/utils.c:6093 #, gcc-internal-format, gfc-internal-format msgid "" "nonnull argument references non-pointer operand (argument %lu, operand %lu)" msgstr "" -#: c-family/c-common.c:8533 +#: c-family/c-common.c:8555 #, gcc-internal-format msgid "not enough variable arguments to fit a sentinel" msgstr "" -#: c-family/c-common.c:8547 +#: c-family/c-common.c:8569 #, gcc-internal-format msgid "missing sentinel in function call" msgstr "" -#: c-family/c-common.c:8588 +#: c-family/c-common.c:8610 #, gcc-internal-format, gfc-internal-format msgid "null argument where non-null required (argument %lu)" msgstr "" -#: c-family/c-common.c:8653 +#: c-family/c-common.c:8675 #, gcc-internal-format msgid "cleanup argument not an identifier" msgstr "" -#: c-family/c-common.c:8660 +#: c-family/c-common.c:8682 #, gcc-internal-format msgid "cleanup argument not a function" msgstr "" -#: c-family/c-common.c:8697 +#: c-family/c-common.c:8719 #, gcc-internal-format msgid "%qE attribute requires prototypes with named arguments" msgstr "" -#: c-family/c-common.c:8705 +#: c-family/c-common.c:8727 #, gcc-internal-format msgid "%qE attribute only applies to variadic functions" msgstr "" -#: c-family/c-common.c:8717 ada/gcc-interface/utils.c:6135 +#: c-family/c-common.c:8739 ada/gcc-interface/utils.c:6135 #, gcc-internal-format msgid "requested position is not an integer constant" msgstr "" -#: c-family/c-common.c:8725 ada/gcc-interface/utils.c:6142 +#: c-family/c-common.c:8747 ada/gcc-interface/utils.c:6142 #, gcc-internal-format msgid "requested position is less than zero" msgstr "" -#: c-family/c-common.c:8843 +#: c-family/c-common.c:8865 #, gcc-internal-format, gfc-internal-format msgid "bad option %s to optimize attribute" msgstr "" -#: c-family/c-common.c:8846 +#: c-family/c-common.c:8868 #, gcc-internal-format, gfc-internal-format msgid "bad option %s to pragma attribute" msgstr "" -#: c-family/c-common.c:9075 +#: c-family/c-common.c:9095 #, gcc-internal-format msgid "not enough arguments to function %qE" msgstr "" -#: c-family/c-common.c:9081 c-family/c-common.c:10007 c/c-typeck.c:2954 +#: c-family/c-common.c:9101 c-family/c-common.c:10027 c/c-typeck.c:2954 #, gcc-internal-format msgid "too many arguments to function %qE" msgstr "" -#: c-family/c-common.c:9111 c-family/c-common.c:9157 +#: c-family/c-common.c:9131 c-family/c-common.c:9177 #, gcc-internal-format msgid "non-floating-point argument in call to function %qE" msgstr "" -#: c-family/c-common.c:9134 +#: c-family/c-common.c:9154 #, gcc-internal-format msgid "non-floating-point arguments in call to function %qE" msgstr "" -#: c-family/c-common.c:9150 +#: c-family/c-common.c:9170 #, gcc-internal-format msgid "non-const integer argument %u in call to function %qE" msgstr "" -#: c-family/c-common.c:9170 +#: c-family/c-common.c:9190 #, gcc-internal-format msgid "non-integer argument 3 in call to function %qE" msgstr "" -#: c-family/c-common.c:9496 +#: c-family/c-common.c:9516 #, gcc-internal-format msgid "cannot apply %<offsetof%> to static data member %qD" msgstr "" -#: c-family/c-common.c:9501 +#: c-family/c-common.c:9521 #, gcc-internal-format msgid "cannot apply %<offsetof%> when %<operator[]%> is overloaded" msgstr "" -#: c-family/c-common.c:9508 +#: c-family/c-common.c:9528 #, gcc-internal-format msgid "cannot apply %<offsetof%> to a non constant address" msgstr "" -#: c-family/c-common.c:9521 cp/typeck.c:5289 +#: c-family/c-common.c:9541 cp/typeck.c:5289 #, gcc-internal-format msgid "attempt to take address of bit-field structure member %qD" msgstr "" -#: c-family/c-common.c:9573 +#: c-family/c-common.c:9593 #, gcc-internal-format msgid "index %E denotes an offset greater than size of %qT" msgstr "" -#: c-family/c-common.c:9613 +#: c-family/c-common.c:9633 #, gcc-internal-format msgid "" "the omitted middle operand in ?: will always be %<true%>, suggest explicit " "middle operand" msgstr "" -#: c-family/c-common.c:9634 +#: c-family/c-common.c:9654 #, gcc-internal-format msgid "assignment of member %qD in read-only object" msgstr "" -#: c-family/c-common.c:9636 +#: c-family/c-common.c:9656 #, gcc-internal-format msgid "increment of member %qD in read-only object" msgstr "" -#: c-family/c-common.c:9638 +#: c-family/c-common.c:9658 #, gcc-internal-format msgid "decrement of member %qD in read-only object" msgstr "" -#: c-family/c-common.c:9640 +#: c-family/c-common.c:9660 #, gcc-internal-format msgid "member %qD in read-only object used as %<asm%> output" msgstr "" -#: c-family/c-common.c:9644 +#: c-family/c-common.c:9664 #, gcc-internal-format msgid "assignment of read-only member %qD" msgstr "" -#: c-family/c-common.c:9645 +#: c-family/c-common.c:9665 #, gcc-internal-format msgid "increment of read-only member %qD" msgstr "" -#: c-family/c-common.c:9646 +#: c-family/c-common.c:9666 #, gcc-internal-format msgid "decrement of read-only member %qD" msgstr "" -#: c-family/c-common.c:9647 +#: c-family/c-common.c:9667 #, gcc-internal-format msgid "read-only member %qD used as %<asm%> output" msgstr "" -#: c-family/c-common.c:9651 +#: c-family/c-common.c:9671 #, gcc-internal-format msgid "assignment of read-only variable %qD" msgstr "" -#: c-family/c-common.c:9652 +#: c-family/c-common.c:9672 #, gcc-internal-format msgid "increment of read-only variable %qD" msgstr "" -#: c-family/c-common.c:9653 +#: c-family/c-common.c:9673 #, gcc-internal-format msgid "decrement of read-only variable %qD" msgstr "" -#: c-family/c-common.c:9654 +#: c-family/c-common.c:9674 #, gcc-internal-format msgid "read-only variable %qD used as %<asm%> output" msgstr "" -#: c-family/c-common.c:9657 +#: c-family/c-common.c:9677 #, gcc-internal-format msgid "assignment of read-only parameter %qD" msgstr "" -#: c-family/c-common.c:9658 +#: c-family/c-common.c:9678 #, gcc-internal-format msgid "increment of read-only parameter %qD" msgstr "" -#: c-family/c-common.c:9659 +#: c-family/c-common.c:9679 #, gcc-internal-format msgid "decrement of read-only parameter %qD" msgstr "" -#: c-family/c-common.c:9660 +#: c-family/c-common.c:9680 #, gcc-internal-format msgid "read-only parameter %qD use as %<asm%> output" msgstr "" -#: c-family/c-common.c:9665 +#: c-family/c-common.c:9685 #, gcc-internal-format msgid "assignment of read-only named return value %qD" msgstr "" -#: c-family/c-common.c:9667 +#: c-family/c-common.c:9687 #, gcc-internal-format msgid "increment of read-only named return value %qD" msgstr "" -#: c-family/c-common.c:9669 +#: c-family/c-common.c:9689 #, gcc-internal-format msgid "decrement of read-only named return value %qD" msgstr "" -#: c-family/c-common.c:9671 +#: c-family/c-common.c:9691 #, gcc-internal-format msgid "read-only named return value %qD used as %<asm%>output" msgstr "" -#: c-family/c-common.c:9676 +#: c-family/c-common.c:9696 #, gcc-internal-format msgid "assignment of function %qD" msgstr "" -#: c-family/c-common.c:9677 +#: c-family/c-common.c:9697 #, gcc-internal-format msgid "increment of function %qD" msgstr "" -#: c-family/c-common.c:9678 +#: c-family/c-common.c:9698 #, gcc-internal-format msgid "decrement of function %qD" msgstr "" -#: c-family/c-common.c:9679 +#: c-family/c-common.c:9699 #, gcc-internal-format msgid "function %qD used as %<asm%> output" msgstr "" -#: c-family/c-common.c:9682 c/c-typeck.c:3902 +#: c-family/c-common.c:9702 c/c-typeck.c:3902 #, gcc-internal-format msgid "assignment of read-only location %qE" msgstr "" -#: c-family/c-common.c:9683 c/c-typeck.c:3905 +#: c-family/c-common.c:9703 c/c-typeck.c:3905 #, gcc-internal-format msgid "increment of read-only location %qE" msgstr "" -#: c-family/c-common.c:9684 c/c-typeck.c:3908 +#: c-family/c-common.c:9704 c/c-typeck.c:3908 #, gcc-internal-format msgid "decrement of read-only location %qE" msgstr "" -#: c-family/c-common.c:9685 +#: c-family/c-common.c:9705 #, gcc-internal-format msgid "read-only location %qE used as %<asm%> output" msgstr "" -#: c-family/c-common.c:9699 +#: c-family/c-common.c:9719 #, gcc-internal-format msgid "lvalue required as left operand of assignment" msgstr "" -#: c-family/c-common.c:9702 +#: c-family/c-common.c:9722 #, gcc-internal-format msgid "lvalue required as increment operand" msgstr "" -#: c-family/c-common.c:9705 +#: c-family/c-common.c:9725 #, gcc-internal-format msgid "lvalue required as decrement operand" msgstr "" -#: c-family/c-common.c:9708 +#: c-family/c-common.c:9728 #, gcc-internal-format msgid "lvalue required as unary %<&%> operand" msgstr "" -#: c-family/c-common.c:9711 +#: c-family/c-common.c:9731 #, gcc-internal-format msgid "lvalue required in asm statement" msgstr "" -#: c-family/c-common.c:9728 +#: c-family/c-common.c:9748 #, gcc-internal-format msgid "invalid type argument (have %qT)" msgstr "" -#: c-family/c-common.c:9732 +#: c-family/c-common.c:9752 #, gcc-internal-format msgid "invalid type argument of array indexing (have %qT)" msgstr "" -#: c-family/c-common.c:9737 +#: c-family/c-common.c:9757 #, gcc-internal-format msgid "invalid type argument of unary %<*%> (have %qT)" msgstr "" -#: c-family/c-common.c:9742 +#: c-family/c-common.c:9762 #, gcc-internal-format msgid "invalid type argument of %<->%> (have %qT)" msgstr "" -#: c-family/c-common.c:9747 +#: c-family/c-common.c:9767 #, gcc-internal-format msgid "invalid type argument of implicit conversion (have %qT)" msgstr "" -#: c-family/c-common.c:9877 cp/init.c:2373 +#: c-family/c-common.c:9897 cp/init.c:2373 #, gcc-internal-format msgid "size of array is too large" msgstr "" -#: c-family/c-common.c:9925 c-family/c-common.c:9981 c/c-typeck.c:3185 +#: c-family/c-common.c:9945 c-family/c-common.c:10001 c/c-typeck.c:3185 #, gcc-internal-format msgid "too few arguments to function %qE" msgstr "" -#: c-family/c-common.c:9942 config/mep/mep.c:6175 c/c-typeck.c:5687 +#: c-family/c-common.c:9962 config/mep/mep.c:6175 c/c-typeck.c:5687 #, gcc-internal-format msgid "incompatible type for argument %d of %qE" msgstr "" -#: c-family/c-common.c:10074 +#: c-family/c-common.c:10094 #, gcc-internal-format msgid "incorrect number of arguments to function %qE" msgstr "" -#: c-family/c-common.c:10082 +#: c-family/c-common.c:10102 #, gcc-internal-format msgid "argument 1 of %qE must be a non-void pointer type" msgstr "" -#: c-family/c-common.c:10091 +#: c-family/c-common.c:10111 #, gcc-internal-format msgid "argument 1 of %qE must be a pointer to a constant size type" msgstr "" -#: c-family/c-common.c:10102 +#: c-family/c-common.c:10122 #, gcc-internal-format msgid "argument 1 of %qE must be a pointer to a nonzero size object" msgstr "" -#: c-family/c-common.c:10117 +#: c-family/c-common.c:10137 #, gcc-internal-format msgid "argument %d of %qE must be a pointer type" msgstr "" -#: c-family/c-common.c:10124 +#: c-family/c-common.c:10144 #, gcc-internal-format msgid "size mismatch in argument %d of %qE" msgstr "" -#: c-family/c-common.c:10140 +#: c-family/c-common.c:10160 #, gcc-internal-format msgid "invalid memory model argument %d of %qE" msgstr "" -#: c-family/c-common.c:10147 +#: c-family/c-common.c:10167 #, gcc-internal-format msgid "non-integer memory model argument %d of %qE" msgstr "" -#: c-family/c-common.c:10674 +#: c-family/c-common.c:10694 #, gcc-internal-format msgid "array subscript has type %<char%>" msgstr "" -#: c-family/c-common.c:10709 c-family/c-common.c:10712 +#: c-family/c-common.c:10729 c-family/c-common.c:10732 #, gcc-internal-format msgid "suggest parentheses around %<+%> inside %<<<%>" msgstr "" -#: c-family/c-common.c:10715 c-family/c-common.c:10718 +#: c-family/c-common.c:10735 c-family/c-common.c:10738 #, gcc-internal-format msgid "suggest parentheses around %<-%> inside %<<<%>" msgstr "" -#: c-family/c-common.c:10724 c-family/c-common.c:10727 +#: c-family/c-common.c:10744 c-family/c-common.c:10747 #, gcc-internal-format msgid "suggest parentheses around %<+%> inside %<>>%>" msgstr "" -#: c-family/c-common.c:10730 c-family/c-common.c:10733 +#: c-family/c-common.c:10750 c-family/c-common.c:10753 #, gcc-internal-format msgid "suggest parentheses around %<-%> inside %<>>%>" msgstr "" -#: c-family/c-common.c:10739 c-family/c-common.c:10742 +#: c-family/c-common.c:10759 c-family/c-common.c:10762 #, gcc-internal-format msgid "suggest parentheses around %<&&%> within %<||%>" msgstr "" -#: c-family/c-common.c:10749 c-family/c-common.c:10753 +#: c-family/c-common.c:10769 c-family/c-common.c:10773 #, gcc-internal-format msgid "suggest parentheses around arithmetic in operand of %<|%>" msgstr "" -#: c-family/c-common.c:10757 c-family/c-common.c:10760 +#: c-family/c-common.c:10777 c-family/c-common.c:10780 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<|%>" msgstr "" -#: c-family/c-common.c:10765 +#: c-family/c-common.c:10785 #, gcc-internal-format msgid "" "suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!" "%> to %<~%>" msgstr "" -#: c-family/c-common.c:10773 c-family/c-common.c:10777 +#: c-family/c-common.c:10793 c-family/c-common.c:10797 #, gcc-internal-format msgid "suggest parentheses around arithmetic in operand of %<^%>" msgstr "" -#: c-family/c-common.c:10781 c-family/c-common.c:10784 +#: c-family/c-common.c:10801 c-family/c-common.c:10804 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<^%>" msgstr "" -#: c-family/c-common.c:10790 c-family/c-common.c:10793 +#: c-family/c-common.c:10810 c-family/c-common.c:10813 #, gcc-internal-format msgid "suggest parentheses around %<+%> in operand of %<&%>" msgstr "" -#: c-family/c-common.c:10796 c-family/c-common.c:10799 +#: c-family/c-common.c:10816 c-family/c-common.c:10819 #, gcc-internal-format msgid "suggest parentheses around %<-%> in operand of %<&%>" msgstr "" -#: c-family/c-common.c:10803 c-family/c-common.c:10806 +#: c-family/c-common.c:10823 c-family/c-common.c:10826 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<&%>" msgstr "" -#: c-family/c-common.c:10811 +#: c-family/c-common.c:10831 #, gcc-internal-format msgid "" "suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!" "%> to %<~%>" msgstr "" -#: c-family/c-common.c:10818 c-family/c-common.c:10821 +#: c-family/c-common.c:10838 c-family/c-common.c:10841 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<==%>" msgstr "" -#: c-family/c-common.c:10826 c-family/c-common.c:10829 +#: c-family/c-common.c:10846 c-family/c-common.c:10849 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<!=%>" msgstr "" -#: c-family/c-common.c:10839 c-family/c-common.c:10845 +#: c-family/c-common.c:10859 c-family/c-common.c:10865 #, gcc-internal-format msgid "comparisons like %<X<=Y<=Z%> do not have their mathematical meaning" msgstr "" -#: c-family/c-common.c:10861 +#: c-family/c-common.c:10881 #, gcc-internal-format msgid "label %q+D defined but not used" msgstr "" -#: c-family/c-common.c:10863 +#: c-family/c-common.c:10883 #, gcc-internal-format msgid "label %q+D declared but not defined" msgstr "" -#: c-family/c-common.c:10879 +#: c-family/c-common.c:10899 #, gcc-internal-format msgid "division by zero" msgstr "" -#: c-family/c-common.c:10911 +#: c-family/c-common.c:10931 #, gcc-internal-format msgid "comparison between types %qT and %qT" msgstr "" -#: c-family/c-common.c:10962 +#: c-family/c-common.c:10982 #, gcc-internal-format msgid "comparison between signed and unsigned integer expressions" msgstr "" -#: c-family/c-common.c:11013 +#: c-family/c-common.c:11033 #, gcc-internal-format msgid "promoted ~unsigned is always non-zero" msgstr "" -#: c-family/c-common.c:11016 +#: c-family/c-common.c:11036 #, gcc-internal-format msgid "comparison of promoted ~unsigned with constant" msgstr "" -#: c-family/c-common.c:11026 +#: c-family/c-common.c:11046 #, gcc-internal-format msgid "comparison of promoted ~unsigned with unsigned" msgstr "" -#: c-family/c-common.c:11204 +#: c-family/c-common.c:11224 #, gcc-internal-format msgid "typedef %qD locally defined but not used" msgstr "" -#: c-family/c-common.c:11443 +#: c-family/c-common.c:11463 #, gcc-internal-format msgid "index value is out of bound" msgstr "" -#: c-family/c-common.c:11481 c-family/c-common.c:11531 -#: c-family/c-common.c:11546 +#: c-family/c-common.c:11501 c-family/c-common.c:11551 +#: c-family/c-common.c:11566 #, gcc-internal-format msgid "conversion of scalar %qT to vector %qT involves truncation" msgstr "" @@ -20115,37 +20143,37 @@ msgstr "" msgid "can%'t write to %s: %m" msgstr "" -#: c-family/c-pch.c:191 +#: c-family/c-pch.c:193 #, gcc-internal-format msgid "can%'t write %s: %m" msgstr "" -#: c-family/c-pch.c:219 c-family/c-pch.c:260 c-family/c-pch.c:311 +#: c-family/c-pch.c:221 c-family/c-pch.c:262 c-family/c-pch.c:313 #, gcc-internal-format msgid "can%'t read %s: %m" msgstr "" -#: c-family/c-pch.c:417 +#: c-family/c-pch.c:419 #, gcc-internal-format msgid "pch_preprocess pragma should only be used with -fpreprocessed" msgstr "" -#: c-family/c-pch.c:418 +#: c-family/c-pch.c:420 #, gcc-internal-format msgid "use #include instead" msgstr "" -#: c-family/c-pch.c:424 +#: c-family/c-pch.c:426 #, gcc-internal-format msgid "%s: couldn%'t open PCH file: %m" msgstr "" -#: c-family/c-pch.c:429 +#: c-family/c-pch.c:431 #, gcc-internal-format msgid "use -Winvalid-pch for more information" msgstr "" -#: c-family/c-pch.c:430 +#: c-family/c-pch.c:432 #, gcc-internal-format, gfc-internal-format msgid "%s: PCH file was invalid" msgstr "" @@ -21090,230 +21118,230 @@ msgstr "" #: config/i386/i386.c:34639 config/i386/i386.c:34690 config/i386/i386.c:34762 #: config/m68k/m68k.c:729 config/mcore/mcore.c:3046 config/mep/mep.c:3887 #: config/mep/mep.c:3901 config/mep/mep.c:3975 config/rl78/rl78.c:480 -#: config/rs6000/rs6000.c:24833 config/rx/rx.c:2571 config/sh/sh.c:9515 -#: config/sh/sh.c:9533 config/sh/sh.c:9562 config/sh/sh.c:9644 -#: config/sh/sh.c:9667 config/spu/spu.c:3685 config/stormy16/stormy16.c:2207 +#: config/rs6000/rs6000.c:24833 config/rx/rx.c:2571 config/sh/sh.c:9512 +#: config/sh/sh.c:9530 config/sh/sh.c:9559 config/sh/sh.c:9641 +#: config/sh/sh.c:9664 config/spu/spu.c:3685 config/stormy16/stormy16.c:2207 #: config/v850/v850.c:2082 #, gcc-internal-format msgid "%qE attribute only applies to functions" msgstr "" -#: config/arm/arm.c:19315 +#: config/arm/arm.c:19325 #, gcc-internal-format msgid "unable to compute real location of stacked parameter" msgstr "" -#: config/arm/arm.c:21257 +#: config/arm/arm.c:21267 #, gcc-internal-format msgid "argument must be a constant" msgstr "" #. @@@ better error message -#: config/arm/arm.c:21632 config/arm/arm.c:21736 +#: config/arm/arm.c:21642 config/arm/arm.c:21746 #, gcc-internal-format msgid "selector must be an immediate" msgstr "" -#: config/arm/arm.c:21640 config/arm/arm.c:21685 config/arm/arm.c:21743 -#: config/arm/arm.c:21752 +#: config/arm/arm.c:21650 config/arm/arm.c:21695 config/arm/arm.c:21753 +#: config/arm/arm.c:21762 #, gcc-internal-format msgid "the range of selector should be in 0 to 7" msgstr "" -#: config/arm/arm.c:21645 config/arm/arm.c:21754 +#: config/arm/arm.c:21655 config/arm/arm.c:21764 #, gcc-internal-format msgid "the range of selector should be in 0 to 3" msgstr "" -#: config/arm/arm.c:21650 config/arm/arm.c:21756 +#: config/arm/arm.c:21660 config/arm/arm.c:21766 #, gcc-internal-format msgid "the range of selector should be in 0 to 1" msgstr "" -#: config/arm/arm.c:21822 +#: config/arm/arm.c:21832 #, gcc-internal-format msgid "mask must be an immediate" msgstr "" -#: config/arm/arm.c:21827 +#: config/arm/arm.c:21837 #, gcc-internal-format msgid "the range of mask should be in 0 to 255" msgstr "" -#: config/arm/arm.c:22015 +#: config/arm/arm.c:22025 #, gcc-internal-format msgid "" "the range of count should be in 0 to 32. please check the intrinsic " "_mm_rori_pi16 in code." msgstr "" -#: config/arm/arm.c:22017 +#: config/arm/arm.c:22027 #, gcc-internal-format msgid "" "the range of count should be in 0 to 32. please check the intrinsic " "_mm_rori_pi32 in code." msgstr "" -#: config/arm/arm.c:22019 +#: config/arm/arm.c:22029 #, gcc-internal-format msgid "" "the range of count should be in 0 to 32. please check the intrinsic " "_mm_ror_pi16 in code." msgstr "" -#: config/arm/arm.c:22021 +#: config/arm/arm.c:22031 #, gcc-internal-format msgid "" "the range of count should be in 0 to 32. please check the intrinsic " "_mm_ror_pi32 in code." msgstr "" -#: config/arm/arm.c:22027 +#: config/arm/arm.c:22037 #, gcc-internal-format msgid "" "the range of count should be in 0 to 64. please check the intrinsic " "_mm_rori_si64 in code." msgstr "" -#: config/arm/arm.c:22029 +#: config/arm/arm.c:22039 #, gcc-internal-format msgid "" "the range of count should be in 0 to 64. please check the intrinsic " "_mm_ror_si64 in code." msgstr "" -#: config/arm/arm.c:22034 +#: config/arm/arm.c:22044 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_srli_pi16 in code." msgstr "" -#: config/arm/arm.c:22036 +#: config/arm/arm.c:22046 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_srli_pi32 in code." msgstr "" -#: config/arm/arm.c:22038 +#: config/arm/arm.c:22048 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_srli_si64 in code." msgstr "" -#: config/arm/arm.c:22040 +#: config/arm/arm.c:22050 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_slli_pi16 in code." msgstr "" -#: config/arm/arm.c:22042 +#: config/arm/arm.c:22052 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_slli_pi32 in code." msgstr "" -#: config/arm/arm.c:22044 +#: config/arm/arm.c:22054 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_slli_si64 in code." msgstr "" -#: config/arm/arm.c:22046 +#: config/arm/arm.c:22056 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_srai_pi16 in code." msgstr "" -#: config/arm/arm.c:22048 +#: config/arm/arm.c:22058 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_srai_pi32 in code." msgstr "" -#: config/arm/arm.c:22050 +#: config/arm/arm.c:22060 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic " "_mm_srai_si64 in code." msgstr "" -#: config/arm/arm.c:22052 +#: config/arm/arm.c:22062 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_srl_pi16 " "in code." msgstr "" -#: config/arm/arm.c:22054 +#: config/arm/arm.c:22064 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_srl_pi32 " "in code." msgstr "" -#: config/arm/arm.c:22056 +#: config/arm/arm.c:22066 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_srl_si64 " "in code." msgstr "" -#: config/arm/arm.c:22058 +#: config/arm/arm.c:22068 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_sll_pi16 " "in code." msgstr "" -#: config/arm/arm.c:22060 +#: config/arm/arm.c:22070 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_sll_pi32 " "in code." msgstr "" -#: config/arm/arm.c:22062 +#: config/arm/arm.c:22072 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_sll_si64 " "in code." msgstr "" -#: config/arm/arm.c:22064 +#: config/arm/arm.c:22074 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_sra_pi16 " "in code." msgstr "" -#: config/arm/arm.c:22066 +#: config/arm/arm.c:22076 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_sra_pi32 " "in code." msgstr "" -#: config/arm/arm.c:22068 +#: config/arm/arm.c:22078 #, gcc-internal-format msgid "" "the count should be no less than 0. please check the intrinsic _mm_sra_si64 " "in code." msgstr "" -#: config/arm/arm.c:22787 +#: config/arm/arm.c:22797 #, gcc-internal-format msgid "no low registers available for popping high registers" msgstr "" -#: config/arm/arm.c:23012 +#: config/arm/arm.c:23022 #, gcc-internal-format msgid "interrupt Service Routines cannot be coded in Thumb mode" msgstr "" @@ -21455,24 +21483,29 @@ msgstr "" msgid "MCU %qs supported for assembler only" msgstr "" -#: config/avr/avr.c:11718 +#: config/avr/avr.c:10816 +#, gcc-internal-format +msgid "conversion from address space %qs to address space %qs" +msgstr "" + +#: config/avr/avr.c:11778 #, gcc-internal-format, gfc-internal-format msgid "%s expects a compile time integer constant" msgstr "" -#: config/avr/avr.c:11732 +#: config/avr/avr.c:11792 #, gcc-internal-format, gfc-internal-format msgid "%s expects a compile time long integer constant as first argument" msgstr "" -#: config/avr/avr.c:11760 +#: config/avr/avr.c:11820 #, gcc-internal-format, gfc-internal-format msgid "" "rounding to %d bits has no effect for fixed-point value with %d fractional " "bits" msgstr "" -#: config/avr/avr.c:11769 +#: config/avr/avr.c:11829 #, gcc-internal-format msgid "rounding result will always be 0" msgstr "" @@ -22403,13 +22436,13 @@ msgstr "" msgid "%qE attribute requires a string constant argument" msgstr "" -#: config/ia64/ia64.c:5885 config/pa/pa.c:416 config/sh/sh.c:9351 +#: config/ia64/ia64.c:5885 config/pa/pa.c:416 config/sh/sh.c:9348 #: config/spu/spu.c:4897 #, gcc-internal-format msgid "value of -mfixed-range must have form REG1-REG2" msgstr "" -#: config/ia64/ia64.c:5912 config/pa/pa.c:443 config/sh/sh.c:9377 +#: config/ia64/ia64.c:5912 config/pa/pa.c:443 config/sh/sh.c:9374 #: config/spu/spu.c:4923 #, gcc-internal-format, gfc-internal-format msgid "%s-%s is an empty range" @@ -22481,7 +22514,7 @@ msgid "%qE attribute is not supported for R8C target" msgstr "" #. The argument must be a constant integer. -#: config/m32c/m32c.c:2934 config/sh/sh.c:9570 config/sh/sh.c:9676 +#: config/m32c/m32c.c:2934 config/sh/sh.c:9567 config/sh/sh.c:9673 #, gcc-internal-format msgid "%qE attribute argument not an integer constant" msgstr "" @@ -22820,22 +22853,32 @@ msgstr "" msgid "unexpected %d byte cop instruction" msgstr "" -#: config/microblaze/microblaze.c:1311 +#: config/microblaze/microblaze.c:1676 #, gcc-internal-format msgid "-fPIC/-fpic not supported for this target" msgstr "" -#: config/microblaze/microblaze.c:1323 +#: config/microblaze/microblaze.c:1688 #, gcc-internal-format msgid "%qs is an invalid argument to -mcpu=" msgstr "" -#: config/microblaze/microblaze.c:1372 +#: config/microblaze/microblaze.c:1737 #, gcc-internal-format msgid "-mxl-multiply-high can be used only with -mcpu=v6.00.a or greater" msgstr "" -#: config/microblaze/microblaze.c:1384 +#: config/microblaze/microblaze.c:1753 +#, gcc-internal-format +msgid "-mxl-reorder can be used only with -mcpu=v8.30.a or greater" +msgstr "" + +#: config/microblaze/microblaze.c:1759 +#, gcc-internal-format +msgid "-mxl-reorder requires -mxl-pattern-compare for -mcpu=v8.30.a" +msgstr "" + +#: config/microblaze/microblaze.c:1764 #, gcc-internal-format msgid "-mxl-multiply-high requires -mno-xl-soft-mul" msgstr "" @@ -23975,65 +24018,65 @@ msgstr "" msgid "%qs uses dynamic stack allocation" msgstr "" -#: config/sh/sh.c:906 +#: config/sh/sh.c:903 #, gcc-internal-format msgid "ignoring -fschedule-insns because of exception handling bug" msgstr "" -#: config/sh/sh.c:923 +#: config/sh/sh.c:920 #, gcc-internal-format msgid "" "unwind tables currently require either a frame pointer or -maccumulate-" "outgoing-args for correctness" msgstr "" -#: config/sh/sh.c:8284 +#: config/sh/sh.c:8281 #, gcc-internal-format msgid "__builtin_saveregs not supported by this subtarget" msgstr "" -#: config/sh/sh.c:9439 +#: config/sh/sh.c:9436 #, gcc-internal-format msgid "%qE attribute only applies to interrupt functions" msgstr "" -#: config/sh/sh.c:9509 +#: config/sh/sh.c:9506 #, gcc-internal-format msgid "%qE attribute is supported only for SH2A" msgstr "" -#: config/sh/sh.c:9539 +#: config/sh/sh.c:9536 #, gcc-internal-format msgid "attribute interrupt_handler is not compatible with -m5-compact" msgstr "" -#: config/sh/sh.c:9556 +#: config/sh/sh.c:9553 #, gcc-internal-format msgid "%qE attribute only applies to SH2A" msgstr "" -#: config/sh/sh.c:9578 +#: config/sh/sh.c:9575 #, gcc-internal-format msgid "%qE attribute argument should be between 0 to 255" msgstr "" #. The argument must be a constant string. -#: config/sh/sh.c:9651 +#: config/sh/sh.c:9648 #, gcc-internal-format msgid "%qE attribute argument not a string constant" msgstr "" -#: config/sh/sh.c:12341 +#: config/sh/sh.c:12338 #, gcc-internal-format msgid "r0 needs to be available as a call-clobbered register" msgstr "" -#: config/sh/sh.c:12362 +#: config/sh/sh.c:12359 #, gcc-internal-format msgid "need a second call-clobbered general purpose register" msgstr "" -#: config/sh/sh.c:12370 +#: config/sh/sh.c:12367 #, gcc-internal-format msgid "need a call-clobbered target register" msgstr "" @@ -24778,7 +24821,7 @@ msgid "label %qD defined here" msgstr "" #: c/c-decl.c:3111 c/c-decl.c:3383 c/c-typeck.c:6979 cp/class.c:1339 -#: cp/class.c:2928 +#: cp/class.c:2932 #, gcc-internal-format msgid "%qD declared here" msgstr "" @@ -24949,7 +24992,7 @@ msgstr "" msgid "variable %qD has initializer but incomplete type" msgstr "" -#: c/c-decl.c:4150 cp/decl.c:4529 cp/decl.c:12970 +#: c/c-decl.c:4150 cp/decl.c:4529 cp/decl.c:12961 #, gcc-internal-format msgid "inline function %q+D given attribute noinline" msgstr "" @@ -25084,7 +25127,7 @@ msgstr "" msgid "variable length array %qE is used" msgstr "" -#: c/c-decl.c:4857 cp/decl.c:8274 +#: c/c-decl.c:4857 cp/decl.c:8277 #, gcc-internal-format msgid "variable length array is used" msgstr "" @@ -25169,7 +25212,7 @@ msgstr "" msgid "storage class specified for unnamed parameter" msgstr "" -#: c/c-decl.c:5143 cp/decl.c:9283 +#: c/c-decl.c:5143 cp/decl.c:9279 #, gcc-internal-format msgid "storage class specified for typename" msgstr "" @@ -25318,7 +25361,7 @@ msgstr "" msgid "function definition has qualified void return type" msgstr "" -#: c/c-decl.c:5635 cp/decl.c:9411 +#: c/c-decl.c:5635 cp/decl.c:9407 #, gcc-internal-format msgid "type qualifiers ignored on function return type" msgstr "" @@ -25429,7 +25472,7 @@ msgstr "" msgid "a member of a structure or union cannot have a variably modified type" msgstr "" -#: c/c-decl.c:5915 cp/decl.c:8516 +#: c/c-decl.c:5915 cp/decl.c:8519 #, gcc-internal-format msgid "variable or field %qE declared void" msgstr "" @@ -25854,7 +25897,7 @@ msgstr "" msgid "argument %qD doesn%'t match prototype" msgstr "" -#: c/c-decl.c:8396 cp/decl.c:13848 +#: c/c-decl.c:8396 cp/decl.c:13839 #, gcc-internal-format msgid "no return statement in function returning non-void" msgstr "" @@ -25923,7 +25966,7 @@ msgstr "" msgid "two or more data types in declaration specifiers" msgstr "" -#: c/c-decl.c:8924 cp/parser.c:22803 +#: c/c-decl.c:8924 cp/parser.c:22807 #, gcc-internal-format msgid "%<long long long%> is too long for GCC" msgstr "" @@ -26053,7 +26096,7 @@ msgstr "" msgid "unknown type name %qE" msgstr "" -#: c/c-parser.c:1484 c/c-parser.c:8618 cp/parser.c:28127 +#: c/c-parser.c:1484 c/c-parser.c:8618 cp/parser.c:28131 #, gcc-internal-format msgid "expected declaration specifiers" msgstr "" @@ -26063,7 +26106,7 @@ msgstr "" msgid "expected %<;%>, identifier or %<(%>" msgstr "" -#: c/c-parser.c:1527 cp/parser.c:24553 cp/parser.c:24627 +#: c/c-parser.c:1527 cp/parser.c:24557 cp/parser.c:24631 #, gcc-internal-format msgid "prefix attributes are ignored for methods" msgstr "" @@ -26111,7 +26154,7 @@ msgstr "" msgid "ISO C90 does not support %<_Static_assert%>" msgstr "" -#: c/c-parser.c:1860 c/c-parser.c:3388 c/c-parser.c:8673 cp/parser.c:27998 +#: c/c-parser.c:1860 c/c-parser.c:3388 c/c-parser.c:8673 cp/parser.c:28002 #, gcc-internal-format msgid "expected string literal" msgstr "" @@ -26143,13 +26186,13 @@ msgstr "" #: c/c-parser.c:7409 c/c-parser.c:7417 c/c-parser.c:7446 c/c-parser.c:7459 #: c/c-parser.c:7764 c/c-parser.c:7888 c/c-parser.c:8316 c/c-parser.c:8351 #: c/c-parser.c:8404 c/c-parser.c:8457 c/c-parser.c:8473 c/c-parser.c:8519 -#: c/c-parser.c:8798 c/c-parser.c:9873 c/c-parser.c:10676 cp/parser.c:23013 -#: cp/parser.c:25397 cp/parser.c:25427 cp/parser.c:25497 cp/parser.c:27718 +#: c/c-parser.c:8798 c/c-parser.c:9873 c/c-parser.c:10676 cp/parser.c:23017 +#: cp/parser.c:25401 cp/parser.c:25431 cp/parser.c:25501 cp/parser.c:27722 #, gcc-internal-format msgid "expected identifier" msgstr "" -#: c/c-parser.c:2295 cp/parser.c:14837 +#: c/c-parser.c:2295 cp/parser.c:14839 #, gcc-internal-format msgid "comma at end of enumerator list" msgstr "" @@ -26479,79 +26522,79 @@ msgstr "" msgid "no type or storage class may be specified here," msgstr "" -#: c/c-parser.c:8320 c/c-parser.c:8377 cp/parser.c:25457 +#: c/c-parser.c:8320 c/c-parser.c:8377 cp/parser.c:25461 #, gcc-internal-format msgid "unknown property attribute" msgstr "" -#: c/c-parser.c:8341 cp/parser.c:25417 +#: c/c-parser.c:8341 cp/parser.c:25421 #, gcc-internal-format msgid "missing %<=%> (after %<getter%> attribute)" msgstr "" -#: c/c-parser.c:8344 cp/parser.c:25420 +#: c/c-parser.c:8344 cp/parser.c:25424 #, gcc-internal-format msgid "missing %<=%> (after %<setter%> attribute)" msgstr "" -#: c/c-parser.c:8358 cp/parser.c:25435 +#: c/c-parser.c:8358 cp/parser.c:25439 #, gcc-internal-format msgid "the %<setter%> attribute may only be specified once" msgstr "" -#: c/c-parser.c:8363 cp/parser.c:25441 +#: c/c-parser.c:8363 cp/parser.c:25445 #, gcc-internal-format msgid "setter name must terminate with %<:%>" msgstr "" -#: c/c-parser.c:8370 cp/parser.c:25449 +#: c/c-parser.c:8370 cp/parser.c:25453 #, gcc-internal-format msgid "the %<getter%> attribute may only be specified once" msgstr "" -#: c/c-parser.c:8556 cp/parser.c:28042 +#: c/c-parser.c:8556 cp/parser.c:28046 #, gcc-internal-format msgid "%<#pragma omp barrier%> may only be used in compound statements" msgstr "" -#: c/c-parser.c:8567 cp/parser.c:28057 +#: c/c-parser.c:8567 cp/parser.c:28061 #, gcc-internal-format msgid "%<#pragma omp flush%> may only be used in compound statements" msgstr "" -#: c/c-parser.c:8578 cp/parser.c:28073 +#: c/c-parser.c:8578 cp/parser.c:28077 #, gcc-internal-format msgid "%<#pragma omp taskwait%> may only be used in compound statements" msgstr "" -#: c/c-parser.c:8589 cp/parser.c:28089 +#: c/c-parser.c:8589 cp/parser.c:28093 #, gcc-internal-format msgid "%<#pragma omp taskyield%> may only be used in compound statements" msgstr "" -#: c/c-parser.c:8602 cp/parser.c:28117 +#: c/c-parser.c:8602 cp/parser.c:28121 #, gcc-internal-format msgid "" "%<#pragma omp section%> may only be used in %<#pragma omp sections%> " "construct" msgstr "" -#: c/c-parser.c:8608 cp/parser.c:28032 +#: c/c-parser.c:8608 cp/parser.c:28036 #, gcc-internal-format msgid "%<#pragma GCC pch_preprocess%> must be first" msgstr "" -#: c/c-parser.c:8773 cp/parser.c:25705 +#: c/c-parser.c:8773 cp/parser.c:25709 #, gcc-internal-format msgid "too many %qs clauses" msgstr "" -#: c/c-parser.c:8875 cp/parser.c:25820 +#: c/c-parser.c:8875 cp/parser.c:25824 #, gcc-internal-format msgid "collapse argument needs positive constant integer expression" msgstr "" -#: c/c-parser.c:8941 cp/parser.c:25871 +#: c/c-parser.c:8941 cp/parser.c:25875 #, gcc-internal-format msgid "expected %<none%> or %<shared%>" msgstr "" @@ -26566,44 +26609,44 @@ msgstr "" msgid "%<num_threads%> value must be positive" msgstr "" -#: c/c-parser.c:9192 cp/parser.c:26090 +#: c/c-parser.c:9192 cp/parser.c:26094 #, gcc-internal-format msgid "" "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> " "or %<max%>" msgstr "" -#: c/c-parser.c:9281 cp/parser.c:26175 +#: c/c-parser.c:9281 cp/parser.c:26179 #, gcc-internal-format msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter" msgstr "" -#: c/c-parser.c:9285 cp/parser.c:26178 +#: c/c-parser.c:9285 cp/parser.c:26182 #, gcc-internal-format msgid "schedule %<auto%> does not take a %<chunk_size%> parameter" msgstr "" -#: c/c-parser.c:9303 cp/parser.c:26194 +#: c/c-parser.c:9303 cp/parser.c:26198 #, gcc-internal-format msgid "invalid schedule kind" msgstr "" -#: c/c-parser.c:9431 cp/parser.c:26326 +#: c/c-parser.c:9431 cp/parser.c:26330 #, gcc-internal-format msgid "expected %<#pragma omp%> clause" msgstr "" -#: c/c-parser.c:9440 cp/parser.c:26335 +#: c/c-parser.c:9440 cp/parser.c:26339 #, gcc-internal-format msgid "%qs is not valid for %qs" msgstr "" -#: c/c-parser.c:9732 cp/parser.c:26619 +#: c/c-parser.c:9732 cp/parser.c:26623 #, gcc-internal-format msgid "invalid form of %<#pragma omp atomic%>" msgstr "" -#: c/c-parser.c:9772 c/c-parser.c:9790 cp/parser.c:26650 cp/parser.c:26667 +#: c/c-parser.c:9772 c/c-parser.c:9790 cp/parser.c:26654 cp/parser.c:26671 #, gcc-internal-format msgid "invalid operator for %<#pragma omp atomic%>" msgstr "" @@ -26613,7 +26656,7 @@ msgstr "" msgid "expected %<(%> or end of line" msgstr "" -#: c/c-parser.c:9932 cp/parser.c:26939 +#: c/c-parser.c:9932 cp/parser.c:26943 #, gcc-internal-format msgid "for statement expected" msgstr "" @@ -26628,12 +26671,12 @@ msgstr "" msgid "not enough perfectly nested loops" msgstr "" -#: c/c-parser.c:10119 cp/parser.c:27284 +#: c/c-parser.c:10119 cp/parser.c:27288 #, gcc-internal-format msgid "collapsed loops not perfectly nested" msgstr "" -#: c/c-parser.c:10157 cp/parser.c:27125 cp/parser.c:27163 cp/pt.c:12692 +#: c/c-parser.c:10157 cp/parser.c:27129 cp/parser.c:27167 cp/pt.c:12687 #, gcc-internal-format msgid "iteration variable %qD should not be firstprivate" msgstr "" @@ -26658,28 +26701,28 @@ msgstr "" msgid "%<threadprivate%> %qE has incomplete type" msgstr "" -#: c/c-parser.c:10823 cp/parser.c:27928 +#: c/c-parser.c:10823 cp/parser.c:27932 #, gcc-internal-format msgid "%<__transaction_cancel%> without transactional memory support enabled" msgstr "" -#: c/c-parser.c:10829 cp/parser.c:27934 +#: c/c-parser.c:10829 cp/parser.c:27938 #, gcc-internal-format msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>" msgstr "" -#: c/c-parser.c:10838 cp/parser.c:27943 +#: c/c-parser.c:10838 cp/parser.c:27947 #, gcc-internal-format msgid "" "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>" msgstr "" -#: c/c-parser.c:10840 cp/parser.c:27946 +#: c/c-parser.c:10840 cp/parser.c:27950 #, gcc-internal-format msgid " or a %<transaction_may_cancel_outer%> function" msgstr "" -#: c/c-parser.c:10846 cp/parser.c:27952 +#: c/c-parser.c:10846 cp/parser.c:27956 #, gcc-internal-format msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>" msgstr "" @@ -28265,111 +28308,111 @@ msgstr "" msgid " (you can disable this with -fno-deduce-init-list)" msgstr "" -#: cp/call.c:7153 +#: cp/call.c:7156 #, gcc-internal-format msgid "could not find class$ field in java interface type %qT" msgstr "" -#: cp/call.c:7414 +#: cp/call.c:7417 #, gcc-internal-format msgid "call to non-function %qD" msgstr "" -#: cp/call.c:7459 cp/typeck.c:2680 +#: cp/call.c:7462 cp/typeck.c:2680 #, gcc-internal-format msgid "cannot call constructor %<%T::%D%> directly" msgstr "" -#: cp/call.c:7461 +#: cp/call.c:7464 #, gcc-internal-format msgid " for a function-style cast, remove the redundant %<::%D%>" msgstr "" -#: cp/call.c:7578 +#: cp/call.c:7581 #, gcc-internal-format msgid "no matching function for call to %<%T::operator %T(%A)%#V%>" msgstr "" -#: cp/call.c:7591 +#: cp/call.c:7594 #, gcc-internal-format msgid "no matching function for call to %<%T::%s(%A)%#V%>" msgstr "" -#: cp/call.c:7616 +#: cp/call.c:7619 #, gcc-internal-format msgid "call of overloaded %<%s(%A)%> is ambiguous" msgstr "" -#: cp/call.c:7645 +#: cp/call.c:7661 #, gcc-internal-format msgid "cannot call member function %qD without object" msgstr "" -#: cp/call.c:8410 +#: cp/call.c:8428 #, gcc-internal-format msgid "passing %qT chooses %qT over %qT" msgstr "" -#: cp/call.c:8412 cp/name-lookup.c:5552 +#: cp/call.c:8430 cp/name-lookup.c:5547 #, gcc-internal-format msgid " in call to %qD" msgstr "" -#: cp/call.c:8470 +#: cp/call.c:8488 #, gcc-internal-format msgid "choosing %qD over %qD" msgstr "" -#: cp/call.c:8471 +#: cp/call.c:8489 #, gcc-internal-format msgid " for conversion from %qT to %qT" msgstr "" -#: cp/call.c:8474 +#: cp/call.c:8492 #, gcc-internal-format msgid " because conversion sequence for the argument is better" msgstr "" -#: cp/call.c:8628 +#: cp/call.c:8646 #, gcc-internal-format msgid "default argument mismatch in overload resolution" msgstr "" -#: cp/call.c:8631 +#: cp/call.c:8649 #, gcc-internal-format msgid " candidate 1: %q+#F" msgstr "" -#: cp/call.c:8633 +#: cp/call.c:8651 #, gcc-internal-format msgid " candidate 2: %q+#F" msgstr "" -#: cp/call.c:8677 +#: cp/call.c:8695 #, gcc-internal-format msgid "" "ISO C++ says that these are ambiguous, even though the worst conversion for " "the first is better than the worst conversion for the second:" msgstr "" -#: cp/call.c:8841 +#: cp/call.c:8859 #, gcc-internal-format msgid "could not convert %qE from %qT to %qT" msgstr "" -#: cp/call.c:9034 +#: cp/call.c:9052 #, gcc-internal-format msgid "a temporary bound to %qD only persists until the constructor exits" msgstr "" -#: cp/call.c:9150 +#: cp/call.c:9168 #, gcc-internal-format msgid "" "invalid initialization of non-const reference of type %qT from an rvalue of " "type %qT" msgstr "" -#: cp/call.c:9154 +#: cp/call.c:9172 #, gcc-internal-format msgid "" "invalid initialization of reference of type %qT from expression of type %qT" @@ -28480,372 +28523,372 @@ msgstr "" msgid "no unique final overrider for %qD in %qT" msgstr "" -#: cp/class.c:2648 +#: cp/class.c:2652 #, gcc-internal-format msgid "%q+#D marked final, but is not virtual" msgstr "" -#: cp/class.c:2650 +#: cp/class.c:2654 #, gcc-internal-format msgid "%q+#D marked override, but does not override" msgstr "" #. Here we know it is a hider, and no overrider exists. -#: cp/class.c:2719 +#: cp/class.c:2723 #, gcc-internal-format msgid "%q+D was hidden" msgstr "" -#: cp/class.c:2720 +#: cp/class.c:2724 #, gcc-internal-format msgid " by %q+D" msgstr "" -#: cp/class.c:2763 cp/decl2.c:1365 +#: cp/class.c:2767 cp/decl2.c:1365 #, gcc-internal-format msgid "%q+#D invalid; an anonymous union can only have non-static data members" msgstr "" -#: cp/class.c:2766 +#: cp/class.c:2770 #, gcc-internal-format msgid "" "%q+#D invalid; an anonymous struct can only have non-static data members" msgstr "" -#: cp/class.c:2774 cp/decl2.c:1371 +#: cp/class.c:2778 cp/decl2.c:1371 #, gcc-internal-format msgid "private member %q+#D in anonymous union" msgstr "" -#: cp/class.c:2776 +#: cp/class.c:2780 #, gcc-internal-format msgid "private member %q+#D in anonymous struct" msgstr "" -#: cp/class.c:2781 cp/decl2.c:1373 +#: cp/class.c:2785 cp/decl2.c:1373 #, gcc-internal-format msgid "protected member %q+#D in anonymous union" msgstr "" -#: cp/class.c:2783 +#: cp/class.c:2787 #, gcc-internal-format msgid "protected member %q+#D in anonymous struct" msgstr "" -#: cp/class.c:2927 +#: cp/class.c:2931 #, gcc-internal-format msgid "the ellipsis in %qD is not inherited" msgstr "" -#: cp/class.c:3103 +#: cp/class.c:3106 #, gcc-internal-format msgid "bit-field %q+#D with non-integral type" msgstr "" -#: cp/class.c:3119 +#: cp/class.c:3122 #, gcc-internal-format msgid "bit-field %q+D width not an integer constant" msgstr "" -#: cp/class.c:3124 +#: cp/class.c:3127 #, gcc-internal-format msgid "negative width in bit-field %q+D" msgstr "" -#: cp/class.c:3129 +#: cp/class.c:3132 #, gcc-internal-format msgid "zero width for bit-field %q+D" msgstr "" -#: cp/class.c:3135 +#: cp/class.c:3138 #, gcc-internal-format msgid "width of %q+D exceeds its type" msgstr "" -#: cp/class.c:3139 +#: cp/class.c:3142 #, gcc-internal-format msgid "%q+D is too small to hold all values of %q#T" msgstr "" -#: cp/class.c:3198 +#: cp/class.c:3201 #, gcc-internal-format msgid "member %q+#D with constructor not allowed in union" msgstr "" -#: cp/class.c:3201 +#: cp/class.c:3204 #, gcc-internal-format msgid "member %q+#D with destructor not allowed in union" msgstr "" -#: cp/class.c:3203 +#: cp/class.c:3206 #, gcc-internal-format msgid "member %q+#D with copy assignment operator not allowed in union" msgstr "" -#: cp/class.c:3207 +#: cp/class.c:3210 #, gcc-internal-format msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/class.c:3244 +#: cp/class.c:3247 #, gcc-internal-format msgid "multiple fields in union %qT initialized" msgstr "" -#: cp/class.c:3329 +#: cp/class.c:3332 #, gcc-internal-format msgid "%q+D may not be static because it is a member of a union" msgstr "" -#: cp/class.c:3334 +#: cp/class.c:3337 #, gcc-internal-format msgid "%q+D may not have reference type %qT because it is a member of a union" msgstr "" -#: cp/class.c:3345 +#: cp/class.c:3348 #, gcc-internal-format msgid "field %q+D invalidly declared function type" msgstr "" -#: cp/class.c:3351 +#: cp/class.c:3354 #, gcc-internal-format msgid "field %q+D invalidly declared method type" msgstr "" -#: cp/class.c:3407 +#: cp/class.c:3410 #, gcc-internal-format msgid "ignoring packed attribute because of unpacked non-POD field %q+#D" msgstr "" -#: cp/class.c:3504 +#: cp/class.c:3507 #, gcc-internal-format msgid "field %q+#D with same name as class" msgstr "" -#: cp/class.c:3527 +#: cp/class.c:3530 #, gcc-internal-format msgid "%q#T has pointer data members" msgstr "" -#: cp/class.c:3532 +#: cp/class.c:3535 #, gcc-internal-format msgid " but does not override %<%T(const %T&)%>" msgstr "" -#: cp/class.c:3534 +#: cp/class.c:3537 #, gcc-internal-format msgid " or %<operator=(const %T&)%>" msgstr "" -#: cp/class.c:3538 +#: cp/class.c:3541 #, gcc-internal-format msgid " but does not override %<operator=(const %T&)%>" msgstr "" -#: cp/class.c:4009 +#: cp/class.c:4012 #, gcc-internal-format msgid "" "offset of empty base %qT may not be ABI-compliant and maychange in a future " "version of GCC" msgstr "" -#: cp/class.c:4136 +#: cp/class.c:4139 #, gcc-internal-format msgid "class %qT will be considered nearly empty in a future version of GCC" msgstr "" -#: cp/class.c:4218 +#: cp/class.c:4221 #, gcc-internal-format msgid "initializer specified for non-virtual method %q+D" msgstr "" -#: cp/class.c:4645 +#: cp/class.c:4648 #, gcc-internal-format msgid "method overrides both %<transaction_pure%> and %qE methods" msgstr "" -#: cp/class.c:4666 +#: cp/class.c:4669 #, gcc-internal-format msgid "method declared %qE overriding %qE method" msgstr "" -#: cp/class.c:5132 cp/semantics.c:5826 +#: cp/class.c:5135 cp/semantics.c:5828 #, gcc-internal-format msgid "" "enclosing class of constexpr non-static member function %q+#D is not a " "literal type" msgstr "" -#: cp/class.c:5157 +#: cp/class.c:5160 #, gcc-internal-format msgid "%q+T is not literal because:" msgstr "" -#: cp/class.c:5159 +#: cp/class.c:5162 #, gcc-internal-format msgid " %q+T has a non-trivial destructor" msgstr "" -#: cp/class.c:5164 +#: cp/class.c:5167 #, gcc-internal-format msgid "" " %q+T is not an aggregate, does not have a trivial default constructor, and " "has no constexpr constructor that is not a copy or move constructor" msgstr "" -#: cp/class.c:5200 +#: cp/class.c:5203 #, gcc-internal-format msgid " base class %qT of %q+T is non-literal" msgstr "" -#: cp/class.c:5214 +#: cp/class.c:5217 #, gcc-internal-format msgid " non-static data member %q+D has non-literal type" msgstr "" -#: cp/class.c:5332 +#: cp/class.c:5335 #, gcc-internal-format msgid "non-static reference %q+#D in class without a constructor" msgstr "" -#: cp/class.c:5337 +#: cp/class.c:5340 #, gcc-internal-format msgid "non-static const member %q+#D in class without a constructor" msgstr "" #. If the function is defaulted outside the class, we just #. give the synthesis error. -#: cp/class.c:5363 +#: cp/class.c:5366 #, gcc-internal-format msgid "" "%q+D declared to take const reference, but implicit declaration would take " "non-const" msgstr "" -#: cp/class.c:5587 +#: cp/class.c:5590 #, gcc-internal-format msgid "" "offset of virtual base %qT is not ABI-compliant and may change in a future " "version of GCC" msgstr "" -#: cp/class.c:5688 +#: cp/class.c:5691 #, gcc-internal-format msgid "direct base %qT inaccessible in %qT due to ambiguity" msgstr "" -#: cp/class.c:5700 +#: cp/class.c:5703 #, gcc-internal-format msgid "virtual base %qT inaccessible in %qT due to ambiguity" msgstr "" -#: cp/class.c:5886 +#: cp/class.c:5889 #, gcc-internal-format msgid "" "size assigned to %qT may not be ABI-compliant and may change in a future " "version of GCC" msgstr "" -#: cp/class.c:5926 +#: cp/class.c:5929 #, gcc-internal-format msgid "" "the offset of %qD may not be ABI-compliant and may change in a future " "version of GCC" msgstr "" -#: cp/class.c:5954 +#: cp/class.c:5957 #, gcc-internal-format msgid "" "offset of %q+D is not ABI-compliant and may change in a future version of GCC" msgstr "" -#: cp/class.c:5964 +#: cp/class.c:5967 #, gcc-internal-format msgid "" "%q+D contains empty classes which may cause base classes to be placed at " "different locations in a future version of GCC" msgstr "" -#: cp/class.c:6052 +#: cp/class.c:6055 #, gcc-internal-format msgid "" "layout of classes derived from empty class %qT may change in a future " "version of GCC" msgstr "" -#: cp/class.c:6220 cp/decl.c:12134 cp/parser.c:18856 +#: cp/class.c:6223 cp/decl.c:12125 cp/parser.c:18860 #, gcc-internal-format msgid "redefinition of %q#T" msgstr "" -#: cp/class.c:6369 +#: cp/class.c:6372 #, gcc-internal-format msgid "%q#T has virtual functions and accessible non-virtual destructor" msgstr "" -#: cp/class.c:6395 +#: cp/class.c:6398 #, gcc-internal-format msgid "type transparent %q#T does not have any fields" msgstr "" -#: cp/class.c:6401 +#: cp/class.c:6404 #, gcc-internal-format msgid "type transparent class %qT has base classes" msgstr "" -#: cp/class.c:6405 +#: cp/class.c:6408 #, gcc-internal-format msgid "type transparent class %qT has virtual functions" msgstr "" -#: cp/class.c:6411 +#: cp/class.c:6414 #, gcc-internal-format msgid "" "type transparent %q#T cannot be made transparent because the type of the " "first field has a different ABI from the class overall" msgstr "" -#: cp/class.c:6562 +#: cp/class.c:6565 #, gcc-internal-format msgid "trying to finish struct, but kicked out due to previous parse errors" msgstr "" -#: cp/class.c:7071 +#: cp/class.c:7074 #, gcc-internal-format msgid "language string %<\"%E\"%> not recognized" msgstr "" -#: cp/class.c:7160 +#: cp/class.c:7163 #, gcc-internal-format msgid "cannot resolve overloaded function %qD based on conversion to type %qT" msgstr "" -#: cp/class.c:7280 +#: cp/class.c:7283 #, gcc-internal-format msgid "no matches converting function %qD to type %q#T" msgstr "" -#: cp/class.c:7308 +#: cp/class.c:7311 #, gcc-internal-format msgid "converting overloaded function %qD to type %q#T is ambiguous" msgstr "" -#: cp/class.c:7335 +#: cp/class.c:7338 #, gcc-internal-format msgid "assuming pointer to member %qD" msgstr "" -#: cp/class.c:7338 +#: cp/class.c:7341 #, gcc-internal-format msgid "(a pointer to member can only be formed with %<&%E%>)" msgstr "" -#: cp/class.c:7413 cp/class.c:7447 +#: cp/class.c:7416 cp/class.c:7450 #, gcc-internal-format msgid "not enough type information" msgstr "" -#: cp/class.c:7430 cp/cvt.c:173 cp/cvt.c:199 cp/cvt.c:248 +#: cp/class.c:7433 cp/cvt.c:173 cp/cvt.c:199 cp/cvt.c:248 #, gcc-internal-format msgid "cannot convert %qE from type %qT to type %qT" msgstr "" @@ -28855,12 +28898,12 @@ msgstr "" #. A name N used in a class S shall refer to the same declaration #. in its context and when re-evaluated in the completed scope of #. S. -#: cp/class.c:7742 cp/decl.c:1325 +#: cp/class.c:7745 cp/decl.c:1325 #, gcc-internal-format msgid "declaration of %q#D" msgstr "" -#: cp/class.c:7743 +#: cp/class.c:7746 #, gcc-internal-format msgid "changes meaning of %qD from %q+#D" msgstr "" @@ -30052,249 +30095,249 @@ msgstr "" msgid "function %q#D is initialized like a variable" msgstr "" -#: cp/decl.c:6883 +#: cp/decl.c:6886 #, gcc-internal-format msgid "" "non-local variable %qD declared %<__thread%> needs dynamic initialization" msgstr "" -#: cp/decl.c:6886 +#: cp/decl.c:6889 #, gcc-internal-format msgid "" "non-local variable %qD declared %<__thread%> has a non-trivial destructor" msgstr "" -#: cp/decl.c:6892 +#: cp/decl.c:6895 #, gcc-internal-format msgid "C++11 %<thread_local%> allows dynamic initialization and destruction" msgstr "" -#: cp/decl.c:7119 +#: cp/decl.c:7122 #, gcc-internal-format msgid "initializer fails to determine size of %qT" msgstr "" -#: cp/decl.c:7123 +#: cp/decl.c:7126 #, gcc-internal-format msgid "array size missing in %qT" msgstr "" -#: cp/decl.c:7126 +#: cp/decl.c:7129 #, gcc-internal-format msgid "zero-size array %qT" msgstr "" -#: cp/decl.c:7142 +#: cp/decl.c:7145 #, gcc-internal-format msgid "destructor for alien class %qT cannot be a member" msgstr "" -#: cp/decl.c:7144 +#: cp/decl.c:7147 #, gcc-internal-format msgid "constructor for alien class %qT cannot be a member" msgstr "" -#: cp/decl.c:7168 +#: cp/decl.c:7171 #, gcc-internal-format msgid "%qD declared as a %<virtual%> variable" msgstr "" -#: cp/decl.c:7170 +#: cp/decl.c:7173 #, gcc-internal-format msgid "%qD declared as an %<inline%> variable" msgstr "" -#: cp/decl.c:7172 +#: cp/decl.c:7175 #, gcc-internal-format msgid "" "%<const%> and %<volatile%> function specifiers on %qD invalid in variable " "declaration" msgstr "" -#: cp/decl.c:7177 +#: cp/decl.c:7180 #, gcc-internal-format msgid "%qD declared as a %<virtual%> parameter" msgstr "" -#: cp/decl.c:7179 +#: cp/decl.c:7182 #, gcc-internal-format msgid "%qD declared as an %<inline%> parameter" msgstr "" -#: cp/decl.c:7181 +#: cp/decl.c:7184 #, gcc-internal-format msgid "" "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter " "declaration" msgstr "" -#: cp/decl.c:7186 +#: cp/decl.c:7189 #, gcc-internal-format msgid "%qD declared as a %<virtual%> type" msgstr "" -#: cp/decl.c:7188 +#: cp/decl.c:7191 #, gcc-internal-format msgid "%qD declared as an %<inline%> type" msgstr "" -#: cp/decl.c:7190 +#: cp/decl.c:7193 #, gcc-internal-format msgid "" "%<const%> and %<volatile%> function specifiers on %qD invalid in type " "declaration" msgstr "" -#: cp/decl.c:7195 +#: cp/decl.c:7198 #, gcc-internal-format msgid "%qD declared as a %<virtual%> field" msgstr "" -#: cp/decl.c:7197 +#: cp/decl.c:7200 #, gcc-internal-format msgid "%qD declared as an %<inline%> field" msgstr "" -#: cp/decl.c:7199 +#: cp/decl.c:7202 #, gcc-internal-format msgid "" "%<const%> and %<volatile%> function specifiers on %qD invalid in field " "declaration" msgstr "" -#: cp/decl.c:7206 +#: cp/decl.c:7209 #, gcc-internal-format msgid "%q+D declared as a friend" msgstr "" -#: cp/decl.c:7212 +#: cp/decl.c:7215 #, gcc-internal-format msgid "%q+D declared with an exception specification" msgstr "" -#: cp/decl.c:7246 +#: cp/decl.c:7249 #, gcc-internal-format msgid "definition of %qD is not in namespace enclosing %qT" msgstr "" -#: cp/decl.c:7286 +#: cp/decl.c:7289 #, gcc-internal-format msgid "static member function %q#D declared with type qualifiers" msgstr "" -#: cp/decl.c:7385 +#: cp/decl.c:7388 #, gcc-internal-format msgid "defining explicit specialization %qD in friend declaration" msgstr "" #. Something like `template <class T> friend void f<T>()'. -#: cp/decl.c:7395 +#: cp/decl.c:7398 #, gcc-internal-format msgid "invalid use of template-id %qD in declaration of primary template" msgstr "" -#: cp/decl.c:7425 +#: cp/decl.c:7428 #, gcc-internal-format msgid "" "default arguments are not allowed in declaration of friend template " "specialization %qD" msgstr "" -#: cp/decl.c:7433 +#: cp/decl.c:7436 #, gcc-internal-format msgid "" "%<inline%> is not allowed in declaration of friend template specialization " "%qD" msgstr "" -#: cp/decl.c:7475 +#: cp/decl.c:7478 #, gcc-internal-format msgid "cannot declare %<::main%> to be a template" msgstr "" -#: cp/decl.c:7477 +#: cp/decl.c:7480 #, gcc-internal-format msgid "cannot declare %<::main%> to be inline" msgstr "" -#: cp/decl.c:7479 +#: cp/decl.c:7482 #, gcc-internal-format msgid "cannot declare %<::main%> to be static" msgstr "" -#: cp/decl.c:7507 +#: cp/decl.c:7510 #, gcc-internal-format msgid "" "anonymous type with no linkage used to declare function %q#D with linkage" msgstr "" -#: cp/decl.c:7511 cp/decl.c:7879 cp/decl2.c:3864 +#: cp/decl.c:7514 cp/decl.c:7882 cp/decl2.c:3864 #, gcc-internal-format msgid "" "%q+#D does not refer to the unqualified type, so it is not used for linkage" msgstr "" -#: cp/decl.c:7517 +#: cp/decl.c:7520 #, gcc-internal-format msgid "type %qT with no linkage used to declare function %q#D with linkage" msgstr "" -#: cp/decl.c:7539 +#: cp/decl.c:7542 #, gcc-internal-format msgid "static member function %qD cannot have cv-qualifier" msgstr "" -#: cp/decl.c:7540 +#: cp/decl.c:7543 #, gcc-internal-format msgid "non-member function %qD cannot have cv-qualifier" msgstr "" -#: cp/decl.c:7556 +#: cp/decl.c:7559 #, gcc-internal-format msgid "literal operator with C linkage" msgstr "" -#: cp/decl.c:7565 +#: cp/decl.c:7568 #, gcc-internal-format msgid "%qD has invalid argument list" msgstr "" -#: cp/decl.c:7573 +#: cp/decl.c:7576 #, gcc-internal-format msgid "integer suffix %<%s%> shadowed by implementation" msgstr "" -#: cp/decl.c:7579 +#: cp/decl.c:7582 #, gcc-internal-format msgid "floating point suffix %<%s%> shadowed by implementation" msgstr "" -#: cp/decl.c:7585 +#: cp/decl.c:7588 #, gcc-internal-format msgid "%qD must be a non-member function" msgstr "" -#: cp/decl.c:7636 +#: cp/decl.c:7639 #, gcc-internal-format msgid "%<::main%> must return %<int%>" msgstr "" -#: cp/decl.c:7678 +#: cp/decl.c:7681 #, gcc-internal-format msgid "definition of implicitly-declared %qD" msgstr "" -#: cp/decl.c:7683 +#: cp/decl.c:7686 #, gcc-internal-format msgid "definition of explicitly-defaulted %q+D" msgstr "" -#: cp/decl.c:7684 +#: cp/decl.c:7687 #, gcc-internal-format msgid "%q+#D explicitly defaulted here" msgstr "" -#: cp/decl.c:7701 cp/decl2.c:738 +#: cp/decl.c:7704 cp/decl2.c:738 #, gcc-internal-format msgid "no %q#D member function declared in class %qT" msgstr "" @@ -30303,437 +30346,432 @@ msgstr "" #. no linkage can only be used to declare extern "C" #. entities. Since it's not always an error in the #. ISO C++ 90 Standard, we only issue a warning. -#: cp/decl.c:7876 +#: cp/decl.c:7879 #, gcc-internal-format msgid "" "anonymous type with no linkage used to declare variable %q#D with linkage" msgstr "" -#: cp/decl.c:7885 +#: cp/decl.c:7888 #, gcc-internal-format msgid "type %qT with no linkage used to declare variable %q#D with linkage" msgstr "" -#: cp/decl.c:8008 +#: cp/decl.c:8011 #, gcc-internal-format msgid "in-class initialization of static data member %q#D of incomplete type" msgstr "" -#: cp/decl.c:8012 +#: cp/decl.c:8015 #, gcc-internal-format msgid "" "%<constexpr%> needed for in-class initialization of static data member %q#D " "of non-integral type" msgstr "" -#: cp/decl.c:8015 +#: cp/decl.c:8018 #, gcc-internal-format msgid "in-class initialization of static data member %q#D of non-literal type" msgstr "" -#: cp/decl.c:8028 +#: cp/decl.c:8031 #, gcc-internal-format msgid "" "invalid in-class initialization of static data member of non-integral type " "%qT" msgstr "" -#: cp/decl.c:8034 +#: cp/decl.c:8037 #, gcc-internal-format msgid "ISO C++ forbids in-class initialization of non-const static member %qD" msgstr "" -#: cp/decl.c:8038 +#: cp/decl.c:8041 #, gcc-internal-format msgid "" "ISO C++ forbids initialization of member constant %qD of non-integral type " "%qT" msgstr "" -#: cp/decl.c:8144 cp/decl.c:8172 +#: cp/decl.c:8147 cp/decl.c:8175 #, gcc-internal-format msgid "size of array %qD has non-integral type %qT" msgstr "" -#: cp/decl.c:8147 cp/decl.c:8174 +#: cp/decl.c:8150 cp/decl.c:8177 #, gcc-internal-format msgid "size of array has non-integral type %qT" msgstr "" -#: cp/decl.c:8224 +#: cp/decl.c:8227 #, gcc-internal-format msgid "size of array %qD is negative" msgstr "" -#: cp/decl.c:8226 +#: cp/decl.c:8229 #, gcc-internal-format msgid "size of array is negative" msgstr "" -#: cp/decl.c:8240 +#: cp/decl.c:8243 #, gcc-internal-format msgid "ISO C++ forbids zero-size array %qD" msgstr "" -#: cp/decl.c:8242 +#: cp/decl.c:8245 #, gcc-internal-format msgid "ISO C++ forbids zero-size array" msgstr "" -#: cp/decl.c:8254 +#: cp/decl.c:8257 #, gcc-internal-format msgid "size of array %qD is not an integral constant-expression" msgstr "" -#: cp/decl.c:8257 +#: cp/decl.c:8260 #, gcc-internal-format msgid "size of array is not an integral constant-expression" msgstr "" -#: cp/decl.c:8263 +#: cp/decl.c:8266 #, gcc-internal-format msgid "ISO C++ forbids variable length array %qD" msgstr "" -#: cp/decl.c:8265 +#: cp/decl.c:8268 #, gcc-internal-format msgid "ISO C++ forbids variable length array" msgstr "" -#: cp/decl.c:8271 +#: cp/decl.c:8274 #, gcc-internal-format msgid "variable length array %qD is used" msgstr "" -#: cp/decl.c:8323 +#: cp/decl.c:8326 #, gcc-internal-format msgid "overflow in array dimension" msgstr "" -#: cp/decl.c:8383 +#: cp/decl.c:8386 #, gcc-internal-format msgid "declaration of %qD as array of %<auto%>" msgstr "" -#: cp/decl.c:8391 +#: cp/decl.c:8394 #, gcc-internal-format msgid "declaration of %qD as array of void" msgstr "" -#: cp/decl.c:8393 +#: cp/decl.c:8396 #, gcc-internal-format msgid "creating array of void" msgstr "" -#: cp/decl.c:8398 +#: cp/decl.c:8401 #, gcc-internal-format msgid "declaration of %qD as array of functions" msgstr "" -#: cp/decl.c:8400 +#: cp/decl.c:8403 #, gcc-internal-format msgid "creating array of functions" msgstr "" -#: cp/decl.c:8405 +#: cp/decl.c:8408 #, gcc-internal-format msgid "declaration of %qD as array of references" msgstr "" -#: cp/decl.c:8407 +#: cp/decl.c:8410 #, gcc-internal-format msgid "creating array of references" msgstr "" -#: cp/decl.c:8412 +#: cp/decl.c:8415 #, gcc-internal-format msgid "declaration of %qD as array of function members" msgstr "" -#: cp/decl.c:8414 +#: cp/decl.c:8417 #, gcc-internal-format msgid "creating array of function members" msgstr "" -#: cp/decl.c:8428 +#: cp/decl.c:8431 #, gcc-internal-format msgid "" "declaration of %qD as multidimensional array must have bounds for all " "dimensions except the first" msgstr "" -#: cp/decl.c:8432 +#: cp/decl.c:8435 #, gcc-internal-format msgid "" "multidimensional array must have bounds for all dimensions except the first" msgstr "" -#: cp/decl.c:8467 +#: cp/decl.c:8470 #, gcc-internal-format msgid "return type specification for constructor invalid" msgstr "" -#: cp/decl.c:8477 +#: cp/decl.c:8480 #, gcc-internal-format msgid "return type specification for destructor invalid" msgstr "" -#: cp/decl.c:8490 +#: cp/decl.c:8493 #, gcc-internal-format msgid "return type specified for %<operator %T%>" msgstr "" -#: cp/decl.c:8512 +#: cp/decl.c:8515 #, gcc-internal-format msgid "unnamed variable or field declared void" msgstr "" -#: cp/decl.c:8519 +#: cp/decl.c:8522 #, gcc-internal-format msgid "variable or field declared void" msgstr "" -#: cp/decl.c:8720 +#: cp/decl.c:8722 #, gcc-internal-format msgid "invalid use of qualified-name %<::%D%>" msgstr "" -#: cp/decl.c:8723 +#: cp/decl.c:8725 #, gcc-internal-format msgid "invalid use of qualified-name %<%T::%D%>" msgstr "" -#: cp/decl.c:8726 +#: cp/decl.c:8728 #, gcc-internal-format msgid "invalid use of qualified-name %<%D::%D%>" msgstr "" -#: cp/decl.c:8735 +#: cp/decl.c:8737 #, gcc-internal-format msgid "%q#T is not a class or a namespace" msgstr "" -#: cp/decl.c:8743 +#: cp/decl.c:8745 #, gcc-internal-format msgid "type %qT is not derived from type %qT" msgstr "" -#: cp/decl.c:8759 cp/decl.c:8851 cp/decl.c:8860 cp/decl.c:10242 +#: cp/decl.c:8761 cp/decl.c:8853 cp/decl.c:8862 cp/decl.c:10238 #, gcc-internal-format msgid "declaration of %qD as non-function" msgstr "" -#: cp/decl.c:8765 +#: cp/decl.c:8767 #, gcc-internal-format msgid "declaration of %qD as non-member" msgstr "" -#: cp/decl.c:8796 +#: cp/decl.c:8798 #, gcc-internal-format msgid "declarator-id missing; using reserved word %qD" msgstr "" -#: cp/decl.c:8843 +#: cp/decl.c:8845 #, gcc-internal-format msgid "function definition does not declare parameters" msgstr "" -#: cp/decl.c:8868 +#: cp/decl.c:8870 #, gcc-internal-format msgid "declaration of %qD as %<typedef%>" msgstr "" -#: cp/decl.c:8873 +#: cp/decl.c:8875 #, gcc-internal-format msgid "declaration of %qD as parameter" msgstr "" -#: cp/decl.c:8906 +#: cp/decl.c:8908 #, gcc-internal-format msgid "%<constexpr%> cannot appear in a typedef declaration" msgstr "" -#: cp/decl.c:8914 +#: cp/decl.c:8916 #, gcc-internal-format msgid "two or more data types in declaration of %qs" msgstr "" -#: cp/decl.c:8920 +#: cp/decl.c:8922 #, gcc-internal-format msgid "conflicting specifiers in declaration of %qs" msgstr "" -#: cp/decl.c:8992 cp/decl.c:8995 cp/decl.c:8998 +#: cp/decl.c:8994 cp/decl.c:8997 cp/decl.c:9000 #, gcc-internal-format msgid "ISO C++ forbids declaration of %qs with no type" msgstr "" -#: cp/decl.c:9009 +#: cp/decl.c:9011 #, gcc-internal-format msgid "%<__int128%> is not supported by this target" msgstr "" -#: cp/decl.c:9014 +#: cp/decl.c:9016 #, gcc-internal-format msgid "ISO C++ does not support %<__int128%> for %qs" msgstr "" -#: cp/decl.c:9035 cp/decl.c:9055 +#: cp/decl.c:9037 cp/decl.c:9057 #, gcc-internal-format msgid "%<signed%> or %<unsigned%> invalid for %qs" msgstr "" -#: cp/decl.c:9037 +#: cp/decl.c:9039 #, gcc-internal-format msgid "%<signed%> and %<unsigned%> specified together for %qs" msgstr "" -#: cp/decl.c:9039 +#: cp/decl.c:9041 #, gcc-internal-format msgid "%<long long%> invalid for %qs" msgstr "" -#: cp/decl.c:9041 +#: cp/decl.c:9043 #, gcc-internal-format msgid "%<long%> invalid for %qs" msgstr "" -#: cp/decl.c:9043 +#: cp/decl.c:9045 #, gcc-internal-format msgid "%<short%> invalid for %qs" msgstr "" -#: cp/decl.c:9045 +#: cp/decl.c:9047 #, gcc-internal-format msgid "%<long%> or %<short%> invalid for %qs" msgstr "" -#: cp/decl.c:9047 +#: cp/decl.c:9049 #, gcc-internal-format msgid "%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs" msgstr "" -#: cp/decl.c:9049 +#: cp/decl.c:9051 #, gcc-internal-format msgid "%<long%> or %<short%> specified with char for %qs" msgstr "" -#: cp/decl.c:9051 +#: cp/decl.c:9053 #, gcc-internal-format msgid "%<long%> and %<short%> specified together for %qs" msgstr "" -#: cp/decl.c:9057 +#: cp/decl.c:9059 #, gcc-internal-format msgid "%<short%> or %<long%> invalid for %qs" msgstr "" -#: cp/decl.c:9065 +#: cp/decl.c:9067 #, gcc-internal-format msgid "long, short, signed or unsigned used invalidly for %qs" msgstr "" -#: cp/decl.c:9133 +#: cp/decl.c:9135 #, gcc-internal-format msgid "complex invalid for %qs" msgstr "" -#: cp/decl.c:9161 +#: cp/decl.c:9163 #, gcc-internal-format msgid "qualifiers are not allowed on declaration of %<operator %T%>" msgstr "" -#: cp/decl.c:9193 +#: cp/decl.c:9195 #, gcc-internal-format msgid "member %qD cannot be declared both virtual and static" msgstr "" -#: cp/decl.c:9201 -#, gcc-internal-format -msgid "%<%T::%D%> is not a valid declarator" -msgstr "" - -#: cp/decl.c:9210 +#: cp/decl.c:9206 #, gcc-internal-format msgid "typedef declaration invalid in parameter declaration" msgstr "" -#: cp/decl.c:9215 +#: cp/decl.c:9211 #, gcc-internal-format msgid "storage class specified for template parameter %qs" msgstr "" -#: cp/decl.c:9221 +#: cp/decl.c:9217 #, gcc-internal-format msgid "storage class specifiers invalid in parameter declarations" msgstr "" -#: cp/decl.c:9227 +#: cp/decl.c:9223 #, gcc-internal-format msgid "a parameter cannot be declared %<constexpr%>" msgstr "" -#: cp/decl.c:9236 +#: cp/decl.c:9232 #, gcc-internal-format msgid "%<virtual%> outside class declaration" msgstr "" -#: cp/decl.c:9254 +#: cp/decl.c:9250 #, gcc-internal-format msgid "multiple storage classes in declaration of %qs" msgstr "" -#: cp/decl.c:9277 +#: cp/decl.c:9273 #, gcc-internal-format msgid "storage class specified for %qs" msgstr "" -#: cp/decl.c:9281 +#: cp/decl.c:9277 #, gcc-internal-format msgid "storage class specified for parameter %qs" msgstr "" -#: cp/decl.c:9294 +#: cp/decl.c:9290 #, gcc-internal-format msgid "nested function %qs declared %<extern%>" msgstr "" -#: cp/decl.c:9298 +#: cp/decl.c:9294 #, gcc-internal-format msgid "top-level declaration of %qs specifies %<auto%>" msgstr "" -#: cp/decl.c:9305 +#: cp/decl.c:9301 #, gcc-internal-format msgid "function-scope %qs implicitly auto and declared %<__thread%>" msgstr "" -#: cp/decl.c:9317 +#: cp/decl.c:9313 #, gcc-internal-format msgid "storage class specifiers invalid in friend function declarations" msgstr "" -#: cp/decl.c:9427 +#: cp/decl.c:9423 #, gcc-internal-format msgid "%qs declared as function returning a function" msgstr "" -#: cp/decl.c:9432 +#: cp/decl.c:9428 #, gcc-internal-format msgid "%qs declared as function returning an array" msgstr "" -#: cp/decl.c:9438 +#: cp/decl.c:9434 #, gcc-internal-format msgid "%qs declared as function returning an abstract class type" msgstr "" -#: cp/decl.c:9467 +#: cp/decl.c:9463 #, gcc-internal-format msgid "%qs function uses %<auto%> type specifier without trailing return type" msgstr "" -#: cp/decl.c:9473 +#: cp/decl.c:9469 #, gcc-internal-format msgid "" "%qs function with trailing return type has %qT as its type rather than plain " @@ -30742,466 +30780,466 @@ msgstr "" #. Not using maybe_warn_cpp0x because this should #. always be an error. -#: cp/decl.c:9484 +#: cp/decl.c:9480 #, gcc-internal-format msgid "trailing return type only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/decl.c:9487 +#: cp/decl.c:9483 #, gcc-internal-format msgid "" "%qs function with trailing return type not declared with %<auto%> type " "specifier" msgstr "" -#: cp/decl.c:9520 +#: cp/decl.c:9516 #, gcc-internal-format msgid "destructor cannot be static member function" msgstr "" -#: cp/decl.c:9521 +#: cp/decl.c:9517 #, gcc-internal-format msgid "constructor cannot be static member function" msgstr "" -#: cp/decl.c:9525 +#: cp/decl.c:9521 #, gcc-internal-format msgid "destructors may not be cv-qualified" msgstr "" -#: cp/decl.c:9526 +#: cp/decl.c:9522 #, gcc-internal-format msgid "constructors may not be cv-qualified" msgstr "" -#: cp/decl.c:9543 +#: cp/decl.c:9539 #, gcc-internal-format msgid "constructors cannot be declared virtual" msgstr "" -#: cp/decl.c:9556 +#: cp/decl.c:9552 #, gcc-internal-format msgid "can%'t initialize friend function %qs" msgstr "" #. Cannot be both friend and virtual. -#: cp/decl.c:9560 +#: cp/decl.c:9556 #, gcc-internal-format msgid "virtual functions cannot be friends" msgstr "" -#: cp/decl.c:9564 +#: cp/decl.c:9560 #, gcc-internal-format msgid "friend declaration not in class definition" msgstr "" -#: cp/decl.c:9566 +#: cp/decl.c:9562 #, gcc-internal-format msgid "can%'t define friend function %qs in a local class definition" msgstr "" -#: cp/decl.c:9587 +#: cp/decl.c:9583 #, gcc-internal-format msgid "destructors may not have parameters" msgstr "" -#: cp/decl.c:9613 +#: cp/decl.c:9609 #, gcc-internal-format msgid "cannot declare pointer to %q#T" msgstr "" -#: cp/decl.c:9626 cp/decl.c:9633 +#: cp/decl.c:9622 cp/decl.c:9629 #, gcc-internal-format msgid "cannot declare reference to %q#T" msgstr "" -#: cp/decl.c:9635 +#: cp/decl.c:9631 #, gcc-internal-format msgid "cannot declare pointer to %q#T member" msgstr "" -#: cp/decl.c:9658 +#: cp/decl.c:9654 #, gcc-internal-format msgid "cannot declare reference to qualified function type %qT" msgstr "" -#: cp/decl.c:9659 +#: cp/decl.c:9655 #, gcc-internal-format msgid "cannot declare pointer to qualified function type %qT" msgstr "" -#: cp/decl.c:9733 +#: cp/decl.c:9729 #, gcc-internal-format msgid "" "cannot declare reference to %q#T, which is not a typedef or a template type " "argument" msgstr "" -#: cp/decl.c:9797 +#: cp/decl.c:9793 #, gcc-internal-format msgid "both %<volatile%> and %<constexpr%> cannot be used here" msgstr "" -#: cp/decl.c:9809 +#: cp/decl.c:9805 #, gcc-internal-format msgid "template-id %qD used as a declarator" msgstr "" -#: cp/decl.c:9833 +#: cp/decl.c:9829 #, gcc-internal-format msgid "member functions are implicitly friends of their class" msgstr "" -#: cp/decl.c:9838 +#: cp/decl.c:9834 #, gcc-internal-format msgid "extra qualification %<%T::%> on member %qs" msgstr "" -#: cp/decl.c:9868 +#: cp/decl.c:9864 #, gcc-internal-format msgid "cannot define member function %<%T::%s%> within %<%T%>" msgstr "" -#: cp/decl.c:9870 +#: cp/decl.c:9866 #, gcc-internal-format msgid "cannot declare member function %<%T::%s%> within %<%T%>" msgstr "" -#: cp/decl.c:9879 +#: cp/decl.c:9875 #, gcc-internal-format msgid "cannot declare member %<%T::%s%> within %qT" msgstr "" -#: cp/decl.c:9912 +#: cp/decl.c:9908 #, gcc-internal-format msgid "non-parameter %qs cannot be a parameter pack" msgstr "" -#: cp/decl.c:9922 +#: cp/decl.c:9918 #, gcc-internal-format msgid "size of array %qs is too large" msgstr "" -#: cp/decl.c:9933 +#: cp/decl.c:9929 #, gcc-internal-format msgid "data member may not have variably modified type %qT" msgstr "" -#: cp/decl.c:9935 +#: cp/decl.c:9931 #, gcc-internal-format msgid "parameter may not have variably modified type %qT" msgstr "" #. [dcl.fct.spec] The explicit specifier shall only be used in #. declarations of constructors within a class definition. -#: cp/decl.c:9943 +#: cp/decl.c:9939 #, gcc-internal-format msgid "only declarations of constructors can be %<explicit%>" msgstr "" -#: cp/decl.c:9951 +#: cp/decl.c:9947 #, gcc-internal-format msgid "non-member %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9957 +#: cp/decl.c:9953 #, gcc-internal-format msgid "non-object member %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9963 +#: cp/decl.c:9959 #, gcc-internal-format msgid "function %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9968 +#: cp/decl.c:9964 #, gcc-internal-format msgid "static %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9973 +#: cp/decl.c:9969 #, gcc-internal-format msgid "const %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9978 +#: cp/decl.c:9974 #, gcc-internal-format msgid "reference %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:10013 +#: cp/decl.c:10009 #, gcc-internal-format msgid "typedef declared %<auto%>" msgstr "" -#: cp/decl.c:10023 +#: cp/decl.c:10019 #, gcc-internal-format msgid "typedef name may not be a nested-name-specifier" msgstr "" -#: cp/decl.c:10042 +#: cp/decl.c:10038 #, gcc-internal-format msgid "ISO C++ forbids nested type %qD with same name as enclosing class" msgstr "" -#: cp/decl.c:10143 +#: cp/decl.c:10139 #, gcc-internal-format msgid "" "qualified function types cannot be used to declare static member functions" msgstr "" -#: cp/decl.c:10145 +#: cp/decl.c:10141 #, gcc-internal-format msgid "qualified function types cannot be used to declare free functions" msgstr "" -#: cp/decl.c:10172 +#: cp/decl.c:10168 #, gcc-internal-format msgid "type qualifiers specified for friend class declaration" msgstr "" -#: cp/decl.c:10177 +#: cp/decl.c:10173 #, gcc-internal-format msgid "%<inline%> specified for friend class declaration" msgstr "" -#: cp/decl.c:10185 +#: cp/decl.c:10181 #, gcc-internal-format msgid "template parameters cannot be friends" msgstr "" -#: cp/decl.c:10187 +#: cp/decl.c:10183 #, gcc-internal-format msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>" msgstr "" -#: cp/decl.c:10191 +#: cp/decl.c:10187 #, gcc-internal-format msgid "friend declaration requires class-key, i.e. %<friend %#T%>" msgstr "" -#: cp/decl.c:10204 +#: cp/decl.c:10200 #, gcc-internal-format msgid "trying to make class %qT a friend of global scope" msgstr "" -#: cp/decl.c:10222 +#: cp/decl.c:10218 #, gcc-internal-format msgid "invalid qualifiers on non-member function type" msgstr "" -#: cp/decl.c:10232 +#: cp/decl.c:10228 #, gcc-internal-format msgid "abstract declarator %qT used as declaration" msgstr "" -#: cp/decl.c:10261 +#: cp/decl.c:10257 #, gcc-internal-format msgid "cannot use %<::%> in parameter declaration" msgstr "" -#: cp/decl.c:10265 +#: cp/decl.c:10261 #, gcc-internal-format msgid "parameter declared %<auto%>" msgstr "" -#: cp/decl.c:10308 +#: cp/decl.c:10304 #, gcc-internal-format msgid "non-static data member declared %<auto%>" msgstr "" #. Something like struct S { int N::j; }; -#: cp/decl.c:10330 +#: cp/decl.c:10326 #, gcc-internal-format msgid "invalid use of %<::%>" msgstr "" -#: cp/decl.c:10352 +#: cp/decl.c:10348 #, gcc-internal-format msgid "declaration of function %qD in invalid context" msgstr "" -#: cp/decl.c:10361 +#: cp/decl.c:10357 #, gcc-internal-format msgid "function %qD declared virtual inside a union" msgstr "" -#: cp/decl.c:10370 +#: cp/decl.c:10366 #, gcc-internal-format msgid "%qD cannot be declared virtual, since it is always static" msgstr "" -#: cp/decl.c:10386 +#: cp/decl.c:10382 #, gcc-internal-format msgid "expected qualified name in friend declaration for destructor %qD" msgstr "" -#: cp/decl.c:10393 +#: cp/decl.c:10389 #, gcc-internal-format msgid "declaration of %qD as member of %qT" msgstr "" -#: cp/decl.c:10399 +#: cp/decl.c:10395 #, gcc-internal-format msgid "a destructor cannot be %<constexpr%>" msgstr "" -#: cp/decl.c:10405 +#: cp/decl.c:10401 #, gcc-internal-format msgid "expected qualified name in friend declaration for constructor %qD" msgstr "" -#: cp/decl.c:10451 +#: cp/decl.c:10447 #, gcc-internal-format msgid "field %qD has incomplete type" msgstr "" -#: cp/decl.c:10453 +#: cp/decl.c:10449 #, gcc-internal-format msgid "name %qT has incomplete type" msgstr "" -#: cp/decl.c:10462 +#: cp/decl.c:10458 #, gcc-internal-format msgid " in instantiation of template %qT" msgstr "" -#: cp/decl.c:10471 +#: cp/decl.c:10467 #, gcc-internal-format msgid "%qE is neither function nor member function; cannot be declared friend" msgstr "" -#: cp/decl.c:10528 +#: cp/decl.c:10524 #, gcc-internal-format msgid "constexpr static data member %qD must have an initializer" msgstr "" -#: cp/decl.c:10537 +#: cp/decl.c:10533 #, gcc-internal-format msgid "non-static data member %qE declared %<constexpr%>" msgstr "" -#: cp/decl.c:10587 +#: cp/decl.c:10583 #, gcc-internal-format msgid "storage class %<auto%> invalid for function %qs" msgstr "" -#: cp/decl.c:10589 +#: cp/decl.c:10585 #, gcc-internal-format msgid "storage class %<register%> invalid for function %qs" msgstr "" -#: cp/decl.c:10593 +#: cp/decl.c:10589 #, gcc-internal-format msgid "storage class %<__thread%> invalid for function %qs" msgstr "" -#: cp/decl.c:10596 +#: cp/decl.c:10592 #, gcc-internal-format msgid "storage class %<thread_local%> invalid for function %qs" msgstr "" -#: cp/decl.c:10601 +#: cp/decl.c:10597 #, gcc-internal-format msgid "virt-specifiers in %qs not allowed outside a class definition" msgstr "" -#: cp/decl.c:10612 +#: cp/decl.c:10608 #, gcc-internal-format msgid "" "%<static%> specified invalid for function %qs declared out of global scope" msgstr "" -#: cp/decl.c:10616 +#: cp/decl.c:10612 #, gcc-internal-format msgid "" "%<inline%> specifier invalid for function %qs declared out of global scope" msgstr "" -#: cp/decl.c:10624 +#: cp/decl.c:10620 #, gcc-internal-format msgid "virtual non-class function %qs" msgstr "" -#: cp/decl.c:10631 +#: cp/decl.c:10627 #, gcc-internal-format msgid "%qs defined in a non-class scope" msgstr "" -#: cp/decl.c:10632 +#: cp/decl.c:10628 #, gcc-internal-format msgid "%qs declared in a non-class scope" msgstr "" -#: cp/decl.c:10660 +#: cp/decl.c:10655 #, gcc-internal-format msgid "cannot declare member function %qD to have static linkage" msgstr "" #. FIXME need arm citation -#: cp/decl.c:10667 +#: cp/decl.c:10662 #, gcc-internal-format msgid "cannot declare static function inside another function" msgstr "" -#: cp/decl.c:10697 +#: cp/decl.c:10692 #, gcc-internal-format msgid "" "%<static%> may not be used when defining (as opposed to declaring) a static " "data member" msgstr "" -#: cp/decl.c:10704 +#: cp/decl.c:10699 #, gcc-internal-format msgid "static member %qD declared %<register%>" msgstr "" -#: cp/decl.c:10710 +#: cp/decl.c:10705 #, gcc-internal-format msgid "cannot explicitly declare member %q#D to have extern linkage" msgstr "" -#: cp/decl.c:10717 +#: cp/decl.c:10712 #, gcc-internal-format msgid "declaration of constexpr variable %qD is not a definition" msgstr "" -#: cp/decl.c:10730 +#: cp/decl.c:10725 #, gcc-internal-format msgid "%qs initialized and declared %<extern%>" msgstr "" -#: cp/decl.c:10734 +#: cp/decl.c:10729 #, gcc-internal-format msgid "%qs has both %<extern%> and initializer" msgstr "" -#: cp/decl.c:10880 +#: cp/decl.c:10874 #, gcc-internal-format msgid "default argument %qE uses %qD" msgstr "" -#: cp/decl.c:10882 +#: cp/decl.c:10876 #, gcc-internal-format msgid "default argument %qE uses local variable %qD" msgstr "" -#: cp/decl.c:10970 +#: cp/decl.c:10964 #, gcc-internal-format msgid "parameter %qD has Java class type" msgstr "" -#: cp/decl.c:10998 +#: cp/decl.c:10992 #, gcc-internal-format msgid "parameter %qD invalidly declared method type" msgstr "" -#: cp/decl.c:11023 +#: cp/decl.c:11017 #, gcc-internal-format msgid "parameter %qD includes pointer to array of unknown bound %qT" msgstr "" -#: cp/decl.c:11025 +#: cp/decl.c:11019 #, gcc-internal-format msgid "parameter %qD includes reference to array of unknown bound %qT" msgstr "" @@ -31221,174 +31259,174 @@ msgstr "" #. or implicitly defined), there's no need to worry about their #. existence. Theoretically, they should never even be #. instantiated, but that's hard to forestall. -#: cp/decl.c:11279 +#: cp/decl.c:11273 #, gcc-internal-format msgid "invalid constructor; you probably meant %<%T (const %T&)%>" msgstr "" -#: cp/decl.c:11401 +#: cp/decl.c:11395 #, gcc-internal-format msgid "%qD may not be declared within a namespace" msgstr "" -#: cp/decl.c:11406 +#: cp/decl.c:11400 #, gcc-internal-format msgid "%qD may not be declared as static" msgstr "" -#: cp/decl.c:11432 +#: cp/decl.c:11426 #, gcc-internal-format msgid "%qD must be a nonstatic member function" msgstr "" -#: cp/decl.c:11441 +#: cp/decl.c:11435 #, gcc-internal-format msgid "" "%qD must be either a non-static member function or a non-member function" msgstr "" -#: cp/decl.c:11463 +#: cp/decl.c:11457 #, gcc-internal-format msgid "%qD must have an argument of class or enumerated type" msgstr "" -#: cp/decl.c:11492 +#: cp/decl.c:11486 #, gcc-internal-format msgid "" "conversion to a reference to void will never use a type conversion operator" msgstr "" -#: cp/decl.c:11494 +#: cp/decl.c:11488 #, gcc-internal-format msgid "conversion to void will never use a type conversion operator" msgstr "" -#: cp/decl.c:11501 +#: cp/decl.c:11495 #, gcc-internal-format msgid "" "conversion to a reference to the same type will never use a type conversion " "operator" msgstr "" -#: cp/decl.c:11503 +#: cp/decl.c:11497 #, gcc-internal-format msgid "conversion to the same type will never use a type conversion operator" msgstr "" -#: cp/decl.c:11511 +#: cp/decl.c:11505 #, gcc-internal-format msgid "" "conversion to a reference to a base class will never use a type conversion " "operator" msgstr "" -#: cp/decl.c:11513 +#: cp/decl.c:11507 #, gcc-internal-format msgid "conversion to a base class will never use a type conversion operator" msgstr "" #. 13.4.0.3 -#: cp/decl.c:11522 +#: cp/decl.c:11516 #, gcc-internal-format msgid "ISO C++ prohibits overloading operator ?:" msgstr "" -#: cp/decl.c:11527 +#: cp/decl.c:11521 #, gcc-internal-format msgid "%qD must not have variable number of arguments" msgstr "" -#: cp/decl.c:11578 +#: cp/decl.c:11572 #, gcc-internal-format msgid "postfix %qD must take %<int%> as its argument" msgstr "" -#: cp/decl.c:11581 +#: cp/decl.c:11575 #, gcc-internal-format msgid "postfix %qD must take %<int%> as its second argument" msgstr "" -#: cp/decl.c:11589 +#: cp/decl.c:11583 #, gcc-internal-format msgid "%qD must take either zero or one argument" msgstr "" -#: cp/decl.c:11591 +#: cp/decl.c:11585 #, gcc-internal-format msgid "%qD must take either one or two arguments" msgstr "" -#: cp/decl.c:11613 +#: cp/decl.c:11607 #, gcc-internal-format msgid "prefix %qD should return %qT" msgstr "" -#: cp/decl.c:11619 +#: cp/decl.c:11613 #, gcc-internal-format msgid "postfix %qD should return %qT" msgstr "" -#: cp/decl.c:11628 +#: cp/decl.c:11622 #, gcc-internal-format msgid "%qD must take %<void%>" msgstr "" -#: cp/decl.c:11630 cp/decl.c:11639 +#: cp/decl.c:11624 cp/decl.c:11633 #, gcc-internal-format msgid "%qD must take exactly one argument" msgstr "" -#: cp/decl.c:11641 +#: cp/decl.c:11635 #, gcc-internal-format msgid "%qD must take exactly two arguments" msgstr "" -#: cp/decl.c:11650 +#: cp/decl.c:11644 #, gcc-internal-format msgid "user-defined %qD always evaluates both arguments" msgstr "" -#: cp/decl.c:11664 +#: cp/decl.c:11658 #, gcc-internal-format msgid "%qD should return by value" msgstr "" -#: cp/decl.c:11675 cp/decl.c:11680 +#: cp/decl.c:11669 cp/decl.c:11674 #, gcc-internal-format msgid "%qD cannot have default arguments" msgstr "" -#: cp/decl.c:11741 +#: cp/decl.c:11732 #, gcc-internal-format msgid "using template type parameter %qT after %qs" msgstr "" -#: cp/decl.c:11764 +#: cp/decl.c:11755 #, gcc-internal-format msgid "using alias template specialization %qT after %qs" msgstr "" -#: cp/decl.c:11767 +#: cp/decl.c:11758 #, gcc-internal-format msgid "using typedef-name %qD after %qs" msgstr "" -#: cp/decl.c:11769 +#: cp/decl.c:11760 #, gcc-internal-format msgid "%qD has a previous declaration here" msgstr "" -#: cp/decl.c:11777 +#: cp/decl.c:11768 #, gcc-internal-format msgid "%qT referred to as %qs" msgstr "" -#: cp/decl.c:11778 cp/decl.c:11785 +#: cp/decl.c:11769 cp/decl.c:11776 #, gcc-internal-format msgid "%q+T has a previous declaration here" msgstr "" -#: cp/decl.c:11784 +#: cp/decl.c:11775 #, gcc-internal-format msgid "%qT referred to as enum" msgstr "" @@ -31400,88 +31438,88 @@ msgstr "" #. void f(class C); // No template header here #. #. then the required template argument is missing. -#: cp/decl.c:11799 +#: cp/decl.c:11790 #, gcc-internal-format msgid "template argument required for %<%s %T%>" msgstr "" -#: cp/decl.c:11849 cp/name-lookup.c:3069 +#: cp/decl.c:11840 cp/name-lookup.c:3062 #, gcc-internal-format msgid "%qD has the same name as the class in which it is declared" msgstr "" -#: cp/decl.c:11879 cp/name-lookup.c:2561 cp/name-lookup.c:3395 -#: cp/name-lookup.c:3440 cp/parser.c:5076 cp/parser.c:21175 +#: cp/decl.c:11870 cp/name-lookup.c:2561 cp/name-lookup.c:3390 +#: cp/name-lookup.c:3435 cp/parser.c:5076 cp/parser.c:21179 #, gcc-internal-format msgid "reference to %qD is ambiguous" msgstr "" -#: cp/decl.c:11994 +#: cp/decl.c:11985 #, gcc-internal-format msgid "use of enum %q#D without previous declaration" msgstr "" -#: cp/decl.c:12015 +#: cp/decl.c:12006 #, gcc-internal-format msgid "redeclaration of %qT as a non-template" msgstr "" -#: cp/decl.c:12016 +#: cp/decl.c:12007 #, gcc-internal-format msgid "previous declaration %q+D" msgstr "" -#: cp/decl.c:12157 +#: cp/decl.c:12148 #, gcc-internal-format msgid "derived union %qT invalid" msgstr "" -#: cp/decl.c:12166 +#: cp/decl.c:12157 #, gcc-internal-format msgid "Java class %qT cannot have multiple bases" msgstr "" -#: cp/decl.c:12177 +#: cp/decl.c:12168 #, gcc-internal-format msgid "Java class %qT cannot have virtual bases" msgstr "" -#: cp/decl.c:12197 +#: cp/decl.c:12188 #, gcc-internal-format msgid "base type %qT fails to be a struct or class type" msgstr "" -#: cp/decl.c:12230 +#: cp/decl.c:12221 #, gcc-internal-format msgid "recursive type %qT undefined" msgstr "" -#: cp/decl.c:12232 +#: cp/decl.c:12223 #, gcc-internal-format msgid "duplicate base type %qT invalid" msgstr "" -#: cp/decl.c:12356 +#: cp/decl.c:12347 #, gcc-internal-format msgid "scoped/unscoped mismatch in enum %q#T" msgstr "" -#: cp/decl.c:12359 cp/decl.c:12367 cp/decl.c:12379 cp/parser.c:14742 +#: cp/decl.c:12350 cp/decl.c:12358 cp/decl.c:12370 cp/parser.c:14744 #, gcc-internal-format msgid "previous definition here" msgstr "" -#: cp/decl.c:12364 +#: cp/decl.c:12355 #, gcc-internal-format msgid "underlying type mismatch in enum %q#T" msgstr "" -#: cp/decl.c:12376 +#: cp/decl.c:12367 #, gcc-internal-format msgid "different underlying type in enum %q#T" msgstr "" -#: cp/decl.c:12443 +#: cp/decl.c:12434 #, gcc-internal-format msgid "underlying type %<%T%> of %<%T%> must be an integral type" msgstr "" @@ -31490,82 +31528,82 @@ msgstr "" #. #. IF no integral type can represent all the enumerator values, the #. enumeration is ill-formed. -#: cp/decl.c:12577 +#: cp/decl.c:12568 #, gcc-internal-format msgid "no integral type can represent all of the enumerator values for %qT" msgstr "" -#: cp/decl.c:12718 +#: cp/decl.c:12709 #, gcc-internal-format msgid "enumerator value for %qD is not an integer constant" msgstr "" -#: cp/decl.c:12764 +#: cp/decl.c:12755 #, gcc-internal-format msgid "incremented enumerator value is too large for %<unsigned long%>" msgstr "" -#: cp/decl.c:12776 +#: cp/decl.c:12767 #, gcc-internal-format msgid "overflow in enumeration values at %qD" msgstr "" -#: cp/decl.c:12796 +#: cp/decl.c:12787 #, gcc-internal-format msgid "enumerator value %E is too large for underlying type %<%T%>" msgstr "" -#: cp/decl.c:12886 +#: cp/decl.c:12877 #, gcc-internal-format msgid "return type %q#T is incomplete" msgstr "" -#: cp/decl.c:12888 +#: cp/decl.c:12879 #, gcc-internal-format msgid "return type has Java class type %q#T" msgstr "" -#: cp/decl.c:13012 cp/typeck.c:8247 +#: cp/decl.c:13003 cp/typeck.c:8252 #, gcc-internal-format msgid "%<operator=%> should return a reference to %<*this%>" msgstr "" -#: cp/decl.c:13108 +#: cp/decl.c:13099 #, gcc-internal-format msgid "no previous declaration for %q+D" msgstr "" -#: cp/decl.c:13329 +#: cp/decl.c:13320 #, gcc-internal-format msgid "invalid function declaration" msgstr "" -#: cp/decl.c:13413 +#: cp/decl.c:13404 #, gcc-internal-format msgid "parameter %qD declared void" msgstr "" -#: cp/decl.c:13781 +#: cp/decl.c:13772 #, gcc-internal-format msgid "no return statements in function returning %qT" msgstr "" -#: cp/decl.c:13783 cp/typeck.c:8135 +#: cp/decl.c:13774 cp/typeck.c:8135 #, gcc-internal-format msgid "only plain %<auto%> return type can be deduced to %<void%>" msgstr "" -#: cp/decl.c:13879 +#: cp/decl.c:13870 #, gcc-internal-format msgid "parameter %q+D set but not used" msgstr "" -#: cp/decl.c:13974 +#: cp/decl.c:13965 #, gcc-internal-format msgid "invalid member function declaration" msgstr "" -#: cp/decl.c:13988 +#: cp/decl.c:13979 #, gcc-internal-format msgid "%qD is already defined in class %qT" msgstr "" @@ -31804,105 +31842,105 @@ msgstr "" msgid "use of %qD before deduction of %<auto%>" msgstr "" -#: cp/error.c:3327 +#: cp/error.c:3331 #, gcc-internal-format msgid "" "extended initializer lists only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3332 +#: cp/error.c:3336 #, gcc-internal-format msgid "" "explicit conversion operators only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3337 +#: cp/error.c:3341 #, gcc-internal-format msgid "variadic templates only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3342 +#: cp/error.c:3346 #, gcc-internal-format msgid "lambda expressions only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3347 +#: cp/error.c:3351 #, gcc-internal-format msgid "C++0x auto only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3351 +#: cp/error.c:3355 #, gcc-internal-format msgid "scoped enums only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3355 +#: cp/error.c:3359 #, gcc-internal-format msgid "" "defaulted and deleted functions only available with -std=c++11 or -std=gnu+" "+11" msgstr "" -#: cp/error.c:3360 +#: cp/error.c:3364 #, gcc-internal-format msgid "inline namespaces only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3365 +#: cp/error.c:3369 #, gcc-internal-format msgid "" "override controls (override/final) only available with -std=c++11 or -std=gnu" "++11" msgstr "" -#: cp/error.c:3370 +#: cp/error.c:3374 #, gcc-internal-format msgid "" "non-static data member initializers only available with -std=c++11 or -" "std=gnu++11" msgstr "" -#: cp/error.c:3375 +#: cp/error.c:3379 #, gcc-internal-format msgid "user-defined literals only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3380 +#: cp/error.c:3384 #, gcc-internal-format msgid "delegating constructors only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3385 +#: cp/error.c:3389 #, gcc-internal-format msgid "inheriting constructors only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3390 +#: cp/error.c:3394 #, gcc-internal-format msgid "c++11 attributes only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3439 +#: cp/error.c:3443 #, gcc-internal-format msgid "incomplete type %qT used in nested name specifier" msgstr "" -#: cp/error.c:3443 +#: cp/error.c:3447 #, gcc-internal-format msgid "reference to %<%T::%D%> is ambiguous" msgstr "" -#: cp/error.c:3448 cp/typeck.c:2260 +#: cp/error.c:3452 cp/typeck.c:2260 #, gcc-internal-format msgid "%qD is not a member of %qT" msgstr "" -#: cp/error.c:3452 +#: cp/error.c:3456 #, gcc-internal-format msgid "%qD is not a member of %qD" msgstr "" -#: cp/error.c:3457 +#: cp/error.c:3461 #, gcc-internal-format msgid "%<::%D%> has not been declared" msgstr "" @@ -32816,101 +32854,101 @@ msgstr "" msgid "%qD not declared" msgstr "" -#: cp/name-lookup.c:3218 +#: cp/name-lookup.c:3211 #, gcc-internal-format msgid "using-declaration for non-member at class scope" msgstr "" -#: cp/name-lookup.c:3225 +#: cp/name-lookup.c:3218 #, gcc-internal-format msgid "%<%T::%D%> names destructor" msgstr "" -#: cp/name-lookup.c:3236 +#: cp/name-lookup.c:3231 #, gcc-internal-format msgid "%<%T::%D%> names constructor in %qT" msgstr "" -#: cp/name-lookup.c:3287 +#: cp/name-lookup.c:3282 #, gcc-internal-format msgid "no members matching %<%T::%D%> in %q#T" msgstr "" -#: cp/name-lookup.c:3374 +#: cp/name-lookup.c:3369 #, gcc-internal-format msgid "declaration of %qD not in a namespace surrounding %qD" msgstr "" -#: cp/name-lookup.c:3382 +#: cp/name-lookup.c:3377 #, gcc-internal-format msgid "explicit qualification in declaration of %qD" msgstr "" -#: cp/name-lookup.c:3465 +#: cp/name-lookup.c:3460 #, gcc-internal-format msgid "%qD should have been declared inside %qD" msgstr "" -#: cp/name-lookup.c:3509 +#: cp/name-lookup.c:3504 #, gcc-internal-format msgid "%qD attribute requires a single NTBS argument" msgstr "" -#: cp/name-lookup.c:3516 +#: cp/name-lookup.c:3511 #, gcc-internal-format msgid "" "%qD attribute is meaningless since members of the anonymous namespace get " "local symbols" msgstr "" -#: cp/name-lookup.c:3524 cp/name-lookup.c:3936 +#: cp/name-lookup.c:3519 cp/name-lookup.c:3931 #, gcc-internal-format msgid "%qD attribute directive ignored" msgstr "" -#: cp/name-lookup.c:3588 +#: cp/name-lookup.c:3583 #, gcc-internal-format msgid "namespace alias %qD not allowed here, assuming %qD" msgstr "" -#: cp/name-lookup.c:3924 +#: cp/name-lookup.c:3919 #, gcc-internal-format msgid "strong using only meaningful at namespace scope" msgstr "" -#: cp/name-lookup.c:3928 +#: cp/name-lookup.c:3923 #, gcc-internal-format msgid "current namespace %qD does not enclose strongly used namespace %qD" msgstr "" -#: cp/name-lookup.c:4267 +#: cp/name-lookup.c:4262 #, gcc-internal-format msgid "maximum limit of %d namespaces searched for %qE" msgstr "" -#: cp/name-lookup.c:4277 +#: cp/name-lookup.c:4272 #, gcc-internal-format msgid "suggested alternative:" msgid_plural "suggested alternatives:" msgstr[0] "" msgstr[1] "" -#: cp/name-lookup.c:4281 +#: cp/name-lookup.c:4276 #, gcc-internal-format msgid " %qE" msgstr "" -#: cp/name-lookup.c:5551 +#: cp/name-lookup.c:5546 #, gcc-internal-format msgid "argument dependent lookup finds %q+D" msgstr "" -#: cp/name-lookup.c:6088 +#: cp/name-lookup.c:6083 #, gcc-internal-format msgid "XXX entering pop_everything ()\n" msgstr "" -#: cp/name-lookup.c:6097 +#: cp/name-lookup.c:6092 #, gcc-internal-format msgid "XXX leaving pop_everything ()\n" msgstr "" @@ -33035,7 +33073,7 @@ msgstr "" msgid "floating-point literal cannot appear in a constant-expression" msgstr "" -#: cp/parser.c:2633 cp/pt.c:13527 +#: cp/parser.c:2633 cp/pt.c:13522 #, gcc-internal-format msgid "" "a cast to a type other than an integral or enumeration type cannot appear in " @@ -33285,7 +33323,7 @@ msgid "" "standardization" msgstr "" -#: cp/parser.c:4857 cp/parser.c:16496 +#: cp/parser.c:4857 cp/parser.c:16498 #, gcc-internal-format msgid "expected unqualified-id" msgstr "" @@ -33490,7 +33528,7 @@ msgstr "" msgid "compound-statement in constexpr function" msgstr "" -#: cp/parser.c:9298 cp/parser.c:23016 +#: cp/parser.c:9298 cp/parser.c:23020 #, gcc-internal-format msgid "expected selection-statement" msgstr "" @@ -33525,7 +33563,7 @@ msgid "" "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT" msgstr "" -#: cp/parser.c:9889 cp/parser.c:23019 +#: cp/parser.c:9889 cp/parser.c:23023 #, gcc-internal-format msgid "expected iteration-statement" msgstr "" @@ -33541,12 +33579,12 @@ msgstr "" msgid "ISO C++ forbids computed gotos" msgstr "" -#: cp/parser.c:10071 cp/parser.c:23022 +#: cp/parser.c:10071 cp/parser.c:23026 #, gcc-internal-format msgid "expected jump-statement" msgstr "" -#: cp/parser.c:10203 cp/parser.c:19157 +#: cp/parser.c:10203 cp/parser.c:19161 #, gcc-internal-format msgid "extra %<;%>" msgstr "" @@ -33583,7 +33621,7 @@ msgstr "" msgid "class definition may not be declared a friend" msgstr "" -#: cp/parser.c:11034 cp/parser.c:19551 +#: cp/parser.c:11034 cp/parser.c:19555 #, gcc-internal-format msgid "templates may not be %<virtual%>" msgstr "" @@ -33667,12 +33705,12 @@ msgstr "" msgid "keyword %<export%> not implemented, and will be ignored" msgstr "" -#: cp/parser.c:12317 cp/parser.c:12415 cp/parser.c:12522 cp/parser.c:17611 +#: cp/parser.c:12317 cp/parser.c:12415 cp/parser.c:12522 cp/parser.c:17613 #, gcc-internal-format msgid "template parameter pack %qD cannot have a default argument" msgstr "" -#: cp/parser.c:12321 cp/parser.c:17619 +#: cp/parser.c:12321 cp/parser.c:17621 #, gcc-internal-format msgid "template parameter pack cannot have a default argument" msgstr "" @@ -33687,7 +33725,7 @@ msgstr "" msgid "expected template-id" msgstr "" -#: cp/parser.c:12658 cp/parser.c:22980 +#: cp/parser.c:12658 cp/parser.c:22984 #, gcc-internal-format msgid "expected %<<%>" msgstr "" @@ -33784,167 +33822,167 @@ msgid "" "elaborated-type-specifier for a scoped enum must not use the %<%D%> keyword" msgstr "" -#: cp/parser.c:14355 +#: cp/parser.c:14357 #, gcc-internal-format msgid "declaration %qD does not declare anything" msgstr "" -#: cp/parser.c:14441 +#: cp/parser.c:14443 #, gcc-internal-format msgid "attributes ignored on uninstantiated type" msgstr "" -#: cp/parser.c:14445 +#: cp/parser.c:14447 #, gcc-internal-format msgid "attributes ignored on template instantiation" msgstr "" -#: cp/parser.c:14450 +#: cp/parser.c:14452 #, gcc-internal-format msgid "" "attributes ignored on elaborated-type-specifier that is not a forward " "declaration" msgstr "" -#: cp/parser.c:14584 +#: cp/parser.c:14586 #, gcc-internal-format msgid "%qD is an enumeration template" msgstr "" -#: cp/parser.c:14592 +#: cp/parser.c:14594 #, gcc-internal-format msgid "%qD is not an enumerator-name" msgstr "" -#: cp/parser.c:14655 +#: cp/parser.c:14657 #, gcc-internal-format msgid "expected %<;%> or %<{%>" msgstr "" -#: cp/parser.c:14703 +#: cp/parser.c:14705 #, gcc-internal-format msgid "cannot add an enumerator list to a template instantiation" msgstr "" -#: cp/parser.c:14712 cp/parser.c:18714 +#: cp/parser.c:14714 cp/parser.c:18718 #, gcc-internal-format msgid "declaration of %qD in namespace %qD which does not enclose %qD" msgstr "" -#: cp/parser.c:14717 cp/parser.c:18719 +#: cp/parser.c:14719 cp/parser.c:18723 #, gcc-internal-format msgid "declaration of %qD in %qD which does not enclose %qD" msgstr "" -#: cp/parser.c:14740 +#: cp/parser.c:14742 #, gcc-internal-format msgid "multiple definition of %q#T" msgstr "" -#: cp/parser.c:14767 +#: cp/parser.c:14769 #, gcc-internal-format msgid "opaque-enum-specifier without name" msgstr "" -#: cp/parser.c:14770 +#: cp/parser.c:14772 #, gcc-internal-format msgid "opaque-enum-specifier must use a simple identifier" msgstr "" -#: cp/parser.c:14946 +#: cp/parser.c:14948 #, gcc-internal-format msgid "%qD is not a namespace-name" msgstr "" -#: cp/parser.c:14947 +#: cp/parser.c:14949 #, gcc-internal-format msgid "expected namespace-name" msgstr "" -#: cp/parser.c:15072 +#: cp/parser.c:15074 #, gcc-internal-format msgid "%<namespace%> definition is not allowed here" msgstr "" -#: cp/parser.c:15218 +#: cp/parser.c:15220 #, gcc-internal-format msgid "a template-id may not appear in a using-declaration" msgstr "" -#: cp/parser.c:15258 +#: cp/parser.c:15260 #, gcc-internal-format msgid "" "access declarations are deprecated in favour of using-declarations; " "suggestion: add the %<using%> keyword" msgstr "" -#: cp/parser.c:15323 +#: cp/parser.c:15325 #, gcc-internal-format msgid "types may not be defined in alias template declarations" msgstr "" -#: cp/parser.c:15787 +#: cp/parser.c:15789 #, gcc-internal-format msgid "a function-definition is not allowed here" msgstr "" -#: cp/parser.c:15799 +#: cp/parser.c:15801 #, gcc-internal-format msgid "an asm-specification is not allowed on a function-definition" msgstr "" -#: cp/parser.c:15803 +#: cp/parser.c:15805 #, gcc-internal-format msgid "attributes are not allowed on a function-definition" msgstr "" -#: cp/parser.c:15840 +#: cp/parser.c:15842 #, gcc-internal-format msgid "expected constructor, destructor, or type conversion" msgstr "" #. Anything else is an error. -#: cp/parser.c:15875 cp/parser.c:17782 +#: cp/parser.c:15877 cp/parser.c:17784 #, gcc-internal-format msgid "expected initializer" msgstr "" -#: cp/parser.c:15895 +#: cp/parser.c:15897 #, gcc-internal-format msgid "invalid type in declaration" msgstr "" -#: cp/parser.c:15971 +#: cp/parser.c:15973 #, gcc-internal-format msgid "initializer provided for function" msgstr "" -#: cp/parser.c:16005 +#: cp/parser.c:16007 #, gcc-internal-format msgid "attributes after parenthesized initializer ignored" msgstr "" -#: cp/parser.c:16416 +#: cp/parser.c:16418 #, gcc-internal-format msgid "array bound is not an integer constant" msgstr "" -#: cp/parser.c:16542 +#: cp/parser.c:16544 #, gcc-internal-format msgid "cannot define member of dependent typedef %qT" msgstr "" -#: cp/parser.c:16546 +#: cp/parser.c:16548 #, gcc-internal-format msgid "%<%T::%E%> is not a type" msgstr "" -#: cp/parser.c:16574 +#: cp/parser.c:16576 #, gcc-internal-format msgid "invalid use of constructor as a template" msgstr "" -#: cp/parser.c:16576 +#: cp/parser.c:16578 #, gcc-internal-format msgid "" "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified " @@ -33955,266 +33993,266 @@ msgstr "" #. here because we do not have enough #. information about its original syntactic #. form. -#: cp/parser.c:16593 +#: cp/parser.c:16595 #, gcc-internal-format msgid "invalid declarator" msgstr "" -#: cp/parser.c:16660 +#: cp/parser.c:16662 #, gcc-internal-format msgid "expected declarator" msgstr "" -#: cp/parser.c:16763 +#: cp/parser.c:16765 #, gcc-internal-format msgid "%qD is a namespace" msgstr "" -#: cp/parser.c:16765 +#: cp/parser.c:16767 #, gcc-internal-format msgid "cannot form pointer to member of non-class %q#T" msgstr "" -#: cp/parser.c:16786 +#: cp/parser.c:16788 #, gcc-internal-format msgid "expected ptr-operator" msgstr "" -#: cp/parser.c:16845 +#: cp/parser.c:16847 #, gcc-internal-format msgid "duplicate cv-qualifier" msgstr "" -#: cp/parser.c:16903 +#: cp/parser.c:16905 #, gcc-internal-format msgid "duplicate virt-specifier" msgstr "" -#: cp/parser.c:17065 cp/typeck2.c:448 cp/typeck2.c:1685 +#: cp/parser.c:17067 cp/typeck2.c:448 cp/typeck2.c:1685 #, gcc-internal-format msgid "invalid use of %<auto%>" msgstr "" -#: cp/parser.c:17084 +#: cp/parser.c:17086 #, gcc-internal-format msgid "types may not be defined in template arguments" msgstr "" -#: cp/parser.c:17165 +#: cp/parser.c:17167 #, gcc-internal-format msgid "expected type-specifier" msgstr "" -#: cp/parser.c:17407 +#: cp/parser.c:17409 #, gcc-internal-format msgid "expected %<,%> or %<...%>" msgstr "" -#: cp/parser.c:17464 +#: cp/parser.c:17466 #, gcc-internal-format msgid "types may not be defined in parameter types" msgstr "" -#: cp/parser.c:17590 +#: cp/parser.c:17592 #, gcc-internal-format msgid "deprecated use of default argument for parameter of non-function" msgstr "" -#: cp/parser.c:17594 +#: cp/parser.c:17596 #, gcc-internal-format msgid "default arguments are only permitted for function parameters" msgstr "" -#: cp/parser.c:17613 +#: cp/parser.c:17615 #, gcc-internal-format msgid "parameter pack %qD cannot have a default argument" msgstr "" -#: cp/parser.c:17621 +#: cp/parser.c:17623 #, gcc-internal-format msgid "parameter pack cannot have a default argument" msgstr "" -#: cp/parser.c:17910 +#: cp/parser.c:17914 #, gcc-internal-format msgid "ISO C++ does not allow designated initializers" msgstr "" -#: cp/parser.c:17924 +#: cp/parser.c:17928 #, gcc-internal-format msgid "ISO C++ does not allow C99 designated initializers" msgstr "" -#: cp/parser.c:18032 cp/parser.c:18157 +#: cp/parser.c:18036 cp/parser.c:18161 #, gcc-internal-format msgid "expected class-name" msgstr "" -#: cp/parser.c:18337 +#: cp/parser.c:18341 #, gcc-internal-format msgid "expected %<;%> after class definition" msgstr "" -#: cp/parser.c:18339 +#: cp/parser.c:18343 #, gcc-internal-format msgid "expected %<;%> after struct definition" msgstr "" -#: cp/parser.c:18341 +#: cp/parser.c:18345 #, gcc-internal-format msgid "expected %<;%> after union definition" msgstr "" -#: cp/parser.c:18662 +#: cp/parser.c:18666 #, gcc-internal-format msgid "expected %<{%> or %<:%>" msgstr "" -#: cp/parser.c:18673 +#: cp/parser.c:18677 #, gcc-internal-format msgid "cannot specify %<override%> for a class" msgstr "" -#: cp/parser.c:18681 +#: cp/parser.c:18685 #, gcc-internal-format msgid "global qualification of class name is invalid" msgstr "" -#: cp/parser.c:18688 +#: cp/parser.c:18692 #, gcc-internal-format msgid "qualified name does not name a class" msgstr "" -#: cp/parser.c:18700 +#: cp/parser.c:18704 #, gcc-internal-format msgid "invalid class name in declaration of %qD" msgstr "" -#: cp/parser.c:18733 +#: cp/parser.c:18737 #, gcc-internal-format msgid "extra qualification not allowed" msgstr "" -#: cp/parser.c:18745 +#: cp/parser.c:18749 #, gcc-internal-format msgid "an explicit specialization must be preceded by %<template <>%>" msgstr "" -#: cp/parser.c:18775 +#: cp/parser.c:18779 #, gcc-internal-format msgid "function template %qD redeclared as a class template" msgstr "" -#: cp/parser.c:18806 +#: cp/parser.c:18810 #, gcc-internal-format msgid "could not resolve typename type" msgstr "" -#: cp/parser.c:18858 +#: cp/parser.c:18862 #, gcc-internal-format msgid "previous definition of %q+#T" msgstr "" -#: cp/parser.c:18939 cp/parser.c:23025 +#: cp/parser.c:18943 cp/parser.c:23029 #, gcc-internal-format msgid "expected class-key" msgstr "" -#: cp/parser.c:19177 +#: cp/parser.c:19181 #, gcc-internal-format msgid "in C++03 a class-key must be used when declaring a friend" msgstr "" -#: cp/parser.c:19195 +#: cp/parser.c:19199 #, gcc-internal-format msgid "friend declaration does not name a class or function" msgstr "" -#: cp/parser.c:19213 +#: cp/parser.c:19217 #, gcc-internal-format msgid "a storage class on an anonymous aggregate in class scope is not allowed" msgstr "" -#: cp/parser.c:19418 +#: cp/parser.c:19422 #, gcc-internal-format msgid "pure-specifier on function-definition" msgstr "" -#: cp/parser.c:19462 +#: cp/parser.c:19466 #, gcc-internal-format msgid "stray %<,%> at end of member declaration" msgstr "" -#: cp/parser.c:19474 +#: cp/parser.c:19478 #, gcc-internal-format msgid "expected %<;%> at end of member declaration" msgstr "" -#: cp/parser.c:19545 +#: cp/parser.c:19549 #, gcc-internal-format msgid "invalid pure specifier (only %<= 0%> is allowed)" msgstr "" -#: cp/parser.c:19580 +#: cp/parser.c:19584 #, gcc-internal-format msgid "a brace-enclosed initializer is not allowed here" msgstr "" -#: cp/parser.c:19711 +#: cp/parser.c:19715 #, gcc-internal-format msgid "%<virtual%> specified more than once in base-specified" msgstr "" -#: cp/parser.c:19731 +#: cp/parser.c:19735 #, gcc-internal-format msgid "more than one access specifier in base-specified" msgstr "" -#: cp/parser.c:19755 +#: cp/parser.c:19759 #, gcc-internal-format msgid "keyword %<typename%> not allowed outside of templates" msgstr "" -#: cp/parser.c:19758 +#: cp/parser.c:19762 #, gcc-internal-format msgid "" "keyword %<typename%> not allowed in this context (the base class is " "implicitly a type)" msgstr "" -#: cp/parser.c:19851 cp/parser.c:19933 +#: cp/parser.c:19855 cp/parser.c:19937 #, gcc-internal-format msgid "types may not be defined in an exception-specification" msgstr "" -#: cp/parser.c:19915 +#: cp/parser.c:19919 #, gcc-internal-format msgid "" "dynamic exception specifications are deprecated in C++0x; use %<noexcept%> " "instead" msgstr "" -#: cp/parser.c:20114 +#: cp/parser.c:20118 #, gcc-internal-format msgid "types may not be defined in exception-declarations" msgstr "" -#: cp/parser.c:20665 +#: cp/parser.c:20669 #, gcc-internal-format msgid "expected an identifier for the attribute name" msgstr "" -#: cp/parser.c:21334 +#: cp/parser.c:21338 #, gcc-internal-format msgid "specializing member %<%T::%E%> requires %<template<>%> syntax" msgstr "" -#: cp/parser.c:21339 +#: cp/parser.c:21343 #, gcc-internal-format msgid "invalid declaration of %<%T::%E%>" msgstr "" -#: cp/parser.c:21343 +#: cp/parser.c:21347 #, gcc-internal-format msgid "too few template-parameter-lists" msgstr "" @@ -34223,346 +34261,346 @@ msgstr "" #. something like: #. #. template <class T> template <class U> void S::f(); -#: cp/parser.c:21350 +#: cp/parser.c:21354 #, gcc-internal-format msgid "too many template-parameter-lists" msgstr "" -#: cp/parser.c:21647 +#: cp/parser.c:21651 #, gcc-internal-format msgid "named return values are no longer supported" msgstr "" -#: cp/parser.c:21734 +#: cp/parser.c:21738 #, gcc-internal-format msgid "invalid declaration of member template in local class" msgstr "" -#: cp/parser.c:21743 +#: cp/parser.c:21747 #, gcc-internal-format msgid "template with C linkage" msgstr "" -#: cp/parser.c:21762 +#: cp/parser.c:21766 #, gcc-internal-format msgid "invalid explicit specialization" msgstr "" -#: cp/parser.c:21849 +#: cp/parser.c:21853 #, gcc-internal-format msgid "" "literal operator template %qD has invalid parameter list. Expected non-type " "template argument pack <char...>" msgstr "" -#: cp/parser.c:21923 +#: cp/parser.c:21927 #, gcc-internal-format msgid "template declaration of %<typedef%>" msgstr "" -#: cp/parser.c:22000 +#: cp/parser.c:22004 #, gcc-internal-format msgid "explicit template specialization cannot have a storage class" msgstr "" -#: cp/parser.c:22238 +#: cp/parser.c:22242 #, gcc-internal-format msgid "%<>>%> should be %<> >%> within a nested template argument list" msgstr "" -#: cp/parser.c:22251 +#: cp/parser.c:22255 #, gcc-internal-format msgid "spurious %<>>%>, use %<>%> to terminate a template argument list" msgstr "" -#: cp/parser.c:22608 +#: cp/parser.c:22612 #, gcc-internal-format msgid "%<sizeof...%> argument must be surrounded by parentheses" msgstr "" -#: cp/parser.c:22660 +#: cp/parser.c:22664 #, gcc-internal-format msgid "invalid use of %qD in linkage specification" msgstr "" -#: cp/parser.c:22675 +#: cp/parser.c:22679 #, gcc-internal-format msgid "%<__thread%> before %qD" msgstr "" -#: cp/parser.c:22809 +#: cp/parser.c:22813 #, gcc-internal-format msgid "ISO C++ 1998 does not support %<long long%>" msgstr "" -#: cp/parser.c:22817 +#: cp/parser.c:22821 #, gcc-internal-format msgid "both %<__thread%> and %<thread_local%> specified" msgstr "" -#: cp/parser.c:22819 +#: cp/parser.c:22823 #, gcc-internal-format msgid "duplicate %qD" msgstr "" -#: cp/parser.c:22841 +#: cp/parser.c:22845 #, gcc-internal-format msgid "duplicate %qs" msgstr "" -#: cp/parser.c:22883 +#: cp/parser.c:22887 #, gcc-internal-format msgid "expected %<new%>" msgstr "" -#: cp/parser.c:22886 +#: cp/parser.c:22890 #, gcc-internal-format msgid "expected %<delete%>" msgstr "" -#: cp/parser.c:22889 +#: cp/parser.c:22893 #, gcc-internal-format msgid "expected %<return%>" msgstr "" -#: cp/parser.c:22895 +#: cp/parser.c:22899 #, gcc-internal-format msgid "expected %<extern%>" msgstr "" -#: cp/parser.c:22898 +#: cp/parser.c:22902 #, gcc-internal-format msgid "expected %<static_assert%>" msgstr "" -#: cp/parser.c:22901 +#: cp/parser.c:22905 #, gcc-internal-format msgid "expected %<decltype%>" msgstr "" -#: cp/parser.c:22904 +#: cp/parser.c:22908 #, gcc-internal-format msgid "expected %<operator%>" msgstr "" -#: cp/parser.c:22907 +#: cp/parser.c:22911 #, gcc-internal-format msgid "expected %<class%>" msgstr "" -#: cp/parser.c:22910 +#: cp/parser.c:22914 #, gcc-internal-format msgid "expected %<template%>" msgstr "" -#: cp/parser.c:22913 +#: cp/parser.c:22917 #, gcc-internal-format msgid "expected %<namespace%>" msgstr "" -#: cp/parser.c:22916 +#: cp/parser.c:22920 #, gcc-internal-format msgid "expected %<using%>" msgstr "" -#: cp/parser.c:22919 +#: cp/parser.c:22923 #, gcc-internal-format msgid "expected %<asm%>" msgstr "" -#: cp/parser.c:22922 +#: cp/parser.c:22926 #, gcc-internal-format msgid "expected %<try%>" msgstr "" -#: cp/parser.c:22925 +#: cp/parser.c:22929 #, gcc-internal-format msgid "expected %<catch%>" msgstr "" -#: cp/parser.c:22928 +#: cp/parser.c:22932 #, gcc-internal-format msgid "expected %<throw%>" msgstr "" -#: cp/parser.c:22931 +#: cp/parser.c:22935 #, gcc-internal-format msgid "expected %<__label__%>" msgstr "" -#: cp/parser.c:22934 +#: cp/parser.c:22938 #, gcc-internal-format msgid "expected %<@try%>" msgstr "" -#: cp/parser.c:22937 +#: cp/parser.c:22941 #, gcc-internal-format msgid "expected %<@synchronized%>" msgstr "" -#: cp/parser.c:22940 +#: cp/parser.c:22944 #, gcc-internal-format msgid "expected %<@throw%>" msgstr "" -#: cp/parser.c:22943 +#: cp/parser.c:22947 #, gcc-internal-format msgid "expected %<__transaction_atomic%>" msgstr "" -#: cp/parser.c:22946 +#: cp/parser.c:22950 #, gcc-internal-format msgid "expected %<__transaction_relaxed%>" msgstr "" -#: cp/parser.c:22977 +#: cp/parser.c:22981 #, gcc-internal-format msgid "expected %<::%>" msgstr "" -#: cp/parser.c:22989 +#: cp/parser.c:22993 #, gcc-internal-format msgid "expected %<...%>" msgstr "" -#: cp/parser.c:22992 +#: cp/parser.c:22996 #, gcc-internal-format msgid "expected %<*%>" msgstr "" -#: cp/parser.c:22995 +#: cp/parser.c:22999 #, gcc-internal-format msgid "expected %<~%>" msgstr "" -#: cp/parser.c:23001 +#: cp/parser.c:23005 #, gcc-internal-format msgid "expected %<:%> or %<::%>" msgstr "" -#: cp/parser.c:23029 +#: cp/parser.c:23033 #, gcc-internal-format msgid "expected %<class%>, %<typename%>, or %<template%>" msgstr "" -#: cp/parser.c:23267 +#: cp/parser.c:23271 #, gcc-internal-format msgid "%qs tag used in naming %q#T" msgstr "" -#: cp/parser.c:23272 +#: cp/parser.c:23276 #, gcc-internal-format msgid "%q#T was previously declared here" msgstr "" -#: cp/parser.c:23291 +#: cp/parser.c:23295 #, gcc-internal-format msgid "%qD redeclared with different access" msgstr "" -#: cp/parser.c:23312 +#: cp/parser.c:23316 #, gcc-internal-format msgid "" "in C++98 %<template%> (as a disambiguator) is only allowed within templates" msgstr "" -#: cp/parser.c:23544 +#: cp/parser.c:23548 #, gcc-internal-format msgid "file ends in default argument" msgstr "" -#: cp/parser.c:23748 cp/parser.c:25010 cp/parser.c:25196 +#: cp/parser.c:23752 cp/parser.c:25014 cp/parser.c:25200 #, gcc-internal-format msgid "misplaced %<@%D%> Objective-C++ construct" msgstr "" -#: cp/parser.c:23870 +#: cp/parser.c:23874 #, gcc-internal-format msgid "objective-c++ message argument(s) are expected" msgstr "" -#: cp/parser.c:23899 +#: cp/parser.c:23903 #, gcc-internal-format msgid "%<@encode%> must specify a type as an argument" msgstr "" -#: cp/parser.c:24275 +#: cp/parser.c:24279 #, gcc-internal-format msgid "invalid Objective-C++ selector name" msgstr "" -#: cp/parser.c:24350 cp/parser.c:24368 +#: cp/parser.c:24354 cp/parser.c:24372 #, gcc-internal-format msgid "objective-c++ method declaration is expected" msgstr "" -#: cp/parser.c:24362 cp/parser.c:24427 +#: cp/parser.c:24366 cp/parser.c:24431 #, gcc-internal-format msgid "method attributes must be specified at the end" msgstr "" -#: cp/parser.c:24470 +#: cp/parser.c:24474 #, gcc-internal-format msgid "stray %qs between Objective-C++ methods" msgstr "" -#: cp/parser.c:24676 cp/parser.c:24683 cp/parser.c:24690 +#: cp/parser.c:24680 cp/parser.c:24687 cp/parser.c:24694 #, gcc-internal-format msgid "invalid type for instance variable" msgstr "" -#: cp/parser.c:24804 +#: cp/parser.c:24808 #, gcc-internal-format msgid "identifier expected after %<@protocol%>" msgstr "" -#: cp/parser.c:24975 +#: cp/parser.c:24979 #, gcc-internal-format msgid "" "attributes may not be specified before the %<@%D%> Objective-C++ keyword" msgstr "" -#: cp/parser.c:24982 +#: cp/parser.c:24986 #, gcc-internal-format msgid "prefix attributes are ignored before %<@%D%>" msgstr "" -#: cp/parser.c:25255 cp/parser.c:25262 cp/parser.c:25269 +#: cp/parser.c:25259 cp/parser.c:25266 cp/parser.c:25273 #, gcc-internal-format msgid "invalid type for property" msgstr "" -#: cp/parser.c:27000 +#: cp/parser.c:27004 #, gcc-internal-format msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop" msgstr "" -#: cp/parser.c:27168 cp/pt.c:12695 +#: cp/parser.c:27172 cp/pt.c:12690 #, gcc-internal-format msgid "iteration variable %qD should not be reduction" msgstr "" -#: cp/parser.c:27238 +#: cp/parser.c:27242 #, gcc-internal-format msgid "not enough collapsed for loops" msgstr "" -#: cp/parser.c:27796 cp/semantics.c:5105 +#: cp/parser.c:27800 cp/semantics.c:5105 #, gcc-internal-format msgid "%<__transaction_relaxed%> without transactional memory support enabled" msgstr "" -#: cp/parser.c:27798 cp/semantics.c:5107 +#: cp/parser.c:27802 cp/semantics.c:5107 #, gcc-internal-format msgid "%<__transaction_atomic%> without transactional memory support enabled" msgstr "" -#: cp/parser.c:27995 +#: cp/parser.c:27999 #, gcc-internal-format msgid "junk at end of %<#pragma GCC pch_preprocess%>" msgstr "" -#: cp/parser.c:28174 +#: cp/parser.c:28178 #, gcc-internal-format msgid "inter-module optimizations not implemented for C++" msgstr "" @@ -34682,7 +34720,7 @@ msgstr "" msgid "ambiguous template specialization %qD for %q+D" msgstr "" -#: cp/pt.c:2273 cp/pt.c:17968 +#: cp/pt.c:2273 cp/pt.c:17964 #, gcc-internal-format msgid "%qD is not a static data member of a class template" msgstr "" @@ -35380,256 +35418,256 @@ msgstr "" #. #. is an attempt to declare a variable with function #. type. -#: cp/pt.c:10656 +#: cp/pt.c:10651 #, gcc-internal-format msgid "variable %qD has function type" msgstr "" -#: cp/pt.c:10828 +#: cp/pt.c:10823 #, gcc-internal-format msgid "invalid parameter type %qT" msgstr "" -#: cp/pt.c:10830 +#: cp/pt.c:10825 #, gcc-internal-format msgid "in declaration %q+D" msgstr "" -#: cp/pt.c:10906 +#: cp/pt.c:10901 #, gcc-internal-format msgid "function returning an array" msgstr "" -#: cp/pt.c:10908 +#: cp/pt.c:10903 #, gcc-internal-format msgid "function returning a function" msgstr "" -#: cp/pt.c:10938 +#: cp/pt.c:10933 #, gcc-internal-format msgid "creating pointer to member function of non-class type %qT" msgstr "" -#: cp/pt.c:11503 +#: cp/pt.c:11498 #, gcc-internal-format msgid "forming reference to void" msgstr "" -#: cp/pt.c:11505 +#: cp/pt.c:11500 #, gcc-internal-format msgid "forming pointer to reference type %qT" msgstr "" -#: cp/pt.c:11507 +#: cp/pt.c:11502 #, gcc-internal-format msgid "forming reference to reference type %qT" msgstr "" -#: cp/pt.c:11556 +#: cp/pt.c:11551 #, gcc-internal-format msgid "creating pointer to member of non-class type %qT" msgstr "" -#: cp/pt.c:11562 +#: cp/pt.c:11557 #, gcc-internal-format msgid "creating pointer to member reference type %qT" msgstr "" -#: cp/pt.c:11568 +#: cp/pt.c:11563 #, gcc-internal-format msgid "creating pointer to member of type void" msgstr "" -#: cp/pt.c:11630 +#: cp/pt.c:11625 #, gcc-internal-format msgid "creating array of %qT" msgstr "" -#: cp/pt.c:11636 +#: cp/pt.c:11631 #, gcc-internal-format msgid "creating array of %qT, which is an abstract class type" msgstr "" -#: cp/pt.c:11665 +#: cp/pt.c:11660 #, gcc-internal-format msgid "%qT is not a class, struct, or union type" msgstr "" -#: cp/pt.c:11702 +#: cp/pt.c:11697 #, gcc-internal-format msgid "%qT resolves to %qT, which is not an enumeration type" msgstr "" -#: cp/pt.c:11710 +#: cp/pt.c:11705 #, gcc-internal-format msgid "%qT resolves to %qT, which is is not a class type" msgstr "" -#: cp/pt.c:11827 +#: cp/pt.c:11822 #, gcc-internal-format msgid "use of %qs in template" msgstr "" -#: cp/pt.c:11969 +#: cp/pt.c:11964 #, gcc-internal-format msgid "qualifying type %qT does not match destructor name ~%qT" msgstr "" -#: cp/pt.c:11984 +#: cp/pt.c:11979 #, gcc-internal-format msgid "" "dependent-name %qE is parsed as a non-type, but instantiation yields a type" msgstr "" -#: cp/pt.c:11986 +#: cp/pt.c:11981 #, gcc-internal-format msgid "say %<typename %E%> if a type is meant" msgstr "" -#: cp/pt.c:12134 +#: cp/pt.c:12129 #, gcc-internal-format msgid "using invalid field %qD" msgstr "" -#: cp/pt.c:12502 cp/pt.c:13323 +#: cp/pt.c:12497 cp/pt.c:13318 #, gcc-internal-format msgid "invalid use of pack expansion expression" msgstr "" -#: cp/pt.c:12506 cp/pt.c:13327 +#: cp/pt.c:12501 cp/pt.c:13322 #, gcc-internal-format msgid "use %<...%> to expand argument pack" msgstr "" -#: cp/pt.c:13973 +#: cp/pt.c:13968 #, gcc-internal-format msgid "" "%qD was not declared in this scope, and no declarations were found by " "argument-dependent lookup at the point of instantiation" msgstr "" -#: cp/pt.c:13982 +#: cp/pt.c:13977 #, gcc-internal-format msgid "declarations in dependent base %qT are not found by unqualified lookup" msgstr "" -#: cp/pt.c:13987 +#: cp/pt.c:13982 #, gcc-internal-format msgid "use %<this->%D%> instead" msgstr "" -#: cp/pt.c:13990 +#: cp/pt.c:13985 #, gcc-internal-format msgid "use %<%T::%D%> instead" msgstr "" -#: cp/pt.c:13994 +#: cp/pt.c:13989 #, gcc-internal-format msgid "%q+D declared here, later in the translation unit" msgstr "" -#: cp/pt.c:14254 +#: cp/pt.c:14249 #, gcc-internal-format msgid "%qT is not a class or namespace" msgstr "" -#: cp/pt.c:14257 +#: cp/pt.c:14252 #, gcc-internal-format msgid "%qD is not a class or namespace" msgstr "" -#: cp/pt.c:14563 +#: cp/pt.c:14558 #, gcc-internal-format msgid "%qT is/uses anonymous type" msgstr "" -#: cp/pt.c:14565 +#: cp/pt.c:14560 #, gcc-internal-format msgid "template argument for %qD uses local type %qT" msgstr "" -#: cp/pt.c:14575 +#: cp/pt.c:14570 #, gcc-internal-format msgid "%qT is a variably modified type" msgstr "" -#: cp/pt.c:14589 +#: cp/pt.c:14584 #, gcc-internal-format msgid "integral expression %qE is not constant" msgstr "" -#: cp/pt.c:14607 +#: cp/pt.c:14602 #, gcc-internal-format msgid " trying to instantiate %qD" msgstr "" -#: cp/pt.c:17925 +#: cp/pt.c:17921 #, gcc-internal-format msgid "ambiguous class template instantiation for %q#T" msgstr "" -#: cp/pt.c:17929 +#: cp/pt.c:17925 #, gcc-internal-format msgid "%s %+#T" msgstr "" -#: cp/pt.c:17953 cp/pt.c:18036 +#: cp/pt.c:17949 cp/pt.c:18032 #, gcc-internal-format msgid "explicit instantiation of non-template %q#D" msgstr "" -#: cp/pt.c:17974 cp/pt.c:18031 +#: cp/pt.c:17970 cp/pt.c:18027 #, gcc-internal-format msgid "no matching template for %qD found" msgstr "" -#: cp/pt.c:17979 +#: cp/pt.c:17975 #, gcc-internal-format msgid "" "type %qT for explicit instantiation %qD does not match declared type %qT" msgstr "" -#: cp/pt.c:17987 +#: cp/pt.c:17983 #, gcc-internal-format msgid "explicit instantiation of %q#D" msgstr "" -#: cp/pt.c:18023 +#: cp/pt.c:18019 #, gcc-internal-format msgid "duplicate explicit instantiation of %q#D" msgstr "" -#: cp/pt.c:18046 cp/pt.c:18143 +#: cp/pt.c:18042 cp/pt.c:18139 #, gcc-internal-format msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations" msgstr "" -#: cp/pt.c:18051 cp/pt.c:18160 +#: cp/pt.c:18047 cp/pt.c:18156 #, gcc-internal-format msgid "storage class %qD applied to template instantiation" msgstr "" -#: cp/pt.c:18119 +#: cp/pt.c:18115 #, gcc-internal-format msgid "explicit instantiation of non-class template %qD" msgstr "" -#: cp/pt.c:18121 +#: cp/pt.c:18117 #, gcc-internal-format msgid "explicit instantiation of non-template type %qT" msgstr "" -#: cp/pt.c:18130 +#: cp/pt.c:18126 #, gcc-internal-format msgid "explicit instantiation of %q#T before definition of template" msgstr "" -#: cp/pt.c:18148 +#: cp/pt.c:18144 #, gcc-internal-format msgid "ISO C++ forbids the use of %qE on explicit instantiations" msgstr "" -#: cp/pt.c:18194 +#: cp/pt.c:18190 #, gcc-internal-format msgid "duplicate explicit instantiation of %q#T" msgstr "" @@ -35641,12 +35679,12 @@ msgstr "" #. member function or static data member of a class template #. shall be present in every translation unit in which it is #. explicitly instantiated. -#: cp/pt.c:18723 +#: cp/pt.c:18719 #, gcc-internal-format msgid "explicit instantiation of %qD but no definition available" msgstr "" -#: cp/pt.c:18908 +#: cp/pt.c:18904 #, gcc-internal-format msgid "" "template instantiation depth exceeds maximum of %d instantiating %q+D, " @@ -35654,39 +35692,39 @@ msgid "" "the maximum)" msgstr "" -#: cp/pt.c:19288 +#: cp/pt.c:19284 #, gcc-internal-format msgid "invalid template non-type parameter" msgstr "" -#: cp/pt.c:19290 +#: cp/pt.c:19286 #, gcc-internal-format msgid "%q#T is not a valid type for a template non-type parameter" msgstr "" -#: cp/pt.c:20508 +#: cp/pt.c:20504 #, gcc-internal-format msgid "" "deducing from brace-enclosed initializer list requires #include " "<initializer_list>" msgstr "" -#: cp/pt.c:20579 +#: cp/pt.c:20575 #, gcc-internal-format msgid "unable to deduce lambda return type from %qE" msgstr "" -#: cp/pt.c:20581 +#: cp/pt.c:20577 #, gcc-internal-format msgid "unable to deduce %qT from %qE" msgstr "" -#: cp/pt.c:20595 +#: cp/pt.c:20591 #, gcc-internal-format msgid "inconsistent types %qT and %qT deduced for lambda return type" msgstr "" -#: cp/pt.c:20599 +#: cp/pt.c:20595 #, gcc-internal-format msgid "inconsistent deduction for %qT: %qT and then %qT" msgstr "" @@ -35840,17 +35878,17 @@ msgstr "" msgid "__label__ declarations are only allowed in function scopes" msgstr "" -#: cp/semantics.c:1557 +#: cp/semantics.c:1558 #, gcc-internal-format msgid "invalid use of member %q+D in static member function" msgstr "" -#: cp/semantics.c:1559 +#: cp/semantics.c:1560 #, gcc-internal-format msgid "invalid use of non-static data member %q+D" msgstr "" -#: cp/semantics.c:1560 +#: cp/semantics.c:1561 #, gcc-internal-format msgid "from this location" msgstr "" @@ -35926,7 +35964,7 @@ msgstr "" msgid "invalid base-class specification" msgstr "" -#: cp/semantics.c:3074 cp/semantics.c:9106 +#: cp/semantics.c:3074 cp/semantics.c:9123 #, gcc-internal-format msgid "%qD is not captured" msgstr "" @@ -36056,279 +36094,284 @@ msgid "difference between %qE and %qD does not have integer type" msgstr "" #. Report the error. -#: cp/semantics.c:5224 +#: cp/semantics.c:5226 #, gcc-internal-format, gfc-internal-format msgid "static assertion failed: %s" msgstr "" -#: cp/semantics.c:5227 +#: cp/semantics.c:5229 #, gcc-internal-format msgid "non-constant condition for static assertion" msgstr "" -#: cp/semantics.c:5256 +#: cp/semantics.c:5258 #, gcc-internal-format msgid "argument to decltype must be an expression" msgstr "" -#: cp/semantics.c:5281 +#: cp/semantics.c:5283 #, gcc-internal-format msgid "decltype cannot resolve address of overloaded function" msgstr "" -#: cp/semantics.c:5612 +#: cp/semantics.c:5614 #, gcc-internal-format msgid "__is_convertible_to" msgstr "" -#: cp/semantics.c:5730 +#: cp/semantics.c:5732 #, gcc-internal-format msgid "the type %qT of constexpr variable %qD is not literal" msgstr "" -#: cp/semantics.c:5800 +#: cp/semantics.c:5802 #, gcc-internal-format msgid "invalid type for parameter %d of constexpr function %q+#D" msgstr "" -#: cp/semantics.c:5814 +#: cp/semantics.c:5816 #, gcc-internal-format msgid "invalid return type %qT of constexpr function %q+D" msgstr "" -#: cp/semantics.c:5836 +#: cp/semantics.c:5838 #, gcc-internal-format msgid "%q#T has virtual base classes" msgstr "" -#: cp/semantics.c:6036 +#: cp/semantics.c:6038 #, gcc-internal-format msgid "constexpr constructor does not have empty body" msgstr "" -#: cp/semantics.c:6122 +#: cp/semantics.c:6124 #, gcc-internal-format msgid "body of %<constexpr%> constructor cannot be a function-try-block" msgstr "" -#: cp/semantics.c:6245 +#: cp/semantics.c:6247 #, gcc-internal-format msgid "" "%<constexpr%> constructor for union %qT must initialize exactly one non-" "static data member" msgstr "" -#: cp/semantics.c:6285 +#: cp/semantics.c:6287 #, gcc-internal-format msgid "uninitialized member %qD in %<constexpr%> constructor" msgstr "" -#: cp/semantics.c:6316 +#: cp/semantics.c:6318 #, gcc-internal-format msgid "body of constexpr function %qD not a return-statement" msgstr "" -#: cp/semantics.c:6371 +#: cp/semantics.c:6373 #, gcc-internal-format msgid "%q+D is not usable as a constexpr function because:" msgstr "" -#: cp/semantics.c:6706 +#: cp/semantics.c:6708 #, gcc-internal-format msgid "expression %qE does not designate a constexpr function" msgstr "" -#: cp/semantics.c:6720 cp/semantics.c:8360 +#: cp/semantics.c:6722 cp/semantics.c:8362 #, gcc-internal-format msgid "call to non-constexpr function %qD" msgstr "" #. The definition of fun was somehow unsuitable. -#: cp/semantics.c:6748 +#: cp/semantics.c:6750 #, gcc-internal-format msgid "%qD called in a constant expression" msgstr "" -#: cp/semantics.c:6752 +#: cp/semantics.c:6754 #, gcc-internal-format msgid "%qD used before its definition" msgstr "" -#: cp/semantics.c:6786 +#: cp/semantics.c:6788 #, gcc-internal-format msgid "call has circular dependency" msgstr "" -#: cp/semantics.c:6794 +#: cp/semantics.c:6796 #, gcc-internal-format, gfc-internal-format msgid "" "constexpr evaluation depth exceeds maximum of %d (use -fconstexpr-depth= to " "increase the maximum)" msgstr "" -#: cp/semantics.c:6858 +#: cp/semantics.c:6860 #, gcc-internal-format msgid "%q+E is not a constant expression" msgstr "" -#: cp/semantics.c:7004 +#: cp/semantics.c:7006 #, gcc-internal-format msgid "array subscript out of bound" msgstr "" -#: cp/semantics.c:7050 cp/semantics.c:7110 cp/semantics.c:7804 +#: cp/semantics.c:7052 cp/semantics.c:7112 cp/semantics.c:7806 #, gcc-internal-format msgid "%qE is not a constant expression" msgstr "" -#: cp/semantics.c:7056 +#: cp/semantics.c:7058 #, gcc-internal-format msgid "mutable %qD is not usable in a constant expression" msgstr "" -#: cp/semantics.c:7071 +#: cp/semantics.c:7073 #, gcc-internal-format msgid "" "accessing %qD member instead of initialized %qD member in constant expression" msgstr "" -#: cp/semantics.c:7630 +#: cp/semantics.c:7632 #, gcc-internal-format msgid "accessing value of %qE through a %qT glvalue in a constant expression" msgstr "" -#: cp/semantics.c:7665 +#: cp/semantics.c:7667 #, gcc-internal-format msgid "the value of %qD is not usable in a constant expression" msgstr "" -#: cp/semantics.c:7672 +#: cp/semantics.c:7674 #, gcc-internal-format msgid "%qD used in its own initializer" msgstr "" -#: cp/semantics.c:7677 +#: cp/semantics.c:7679 #, gcc-internal-format msgid "%q#D is not const" msgstr "" -#: cp/semantics.c:7680 +#: cp/semantics.c:7682 #, gcc-internal-format msgid "%q#D is volatile" msgstr "" -#: cp/semantics.c:7684 +#: cp/semantics.c:7686 #, gcc-internal-format msgid "%qD was not initialized with a constant expression" msgstr "" -#: cp/semantics.c:7693 +#: cp/semantics.c:7695 #, gcc-internal-format msgid "%qD was not declared %<constexpr%>" msgstr "" -#: cp/semantics.c:7696 +#: cp/semantics.c:7698 #, gcc-internal-format msgid "%qD does not have integral or enumeration type" msgstr "" -#: cp/semantics.c:7792 cp/semantics.c:8492 +#: cp/semantics.c:7794 cp/semantics.c:8494 #, gcc-internal-format msgid "" "use of the value of the object being constructed in a constant expression" msgstr "" -#: cp/semantics.c:7820 cp/semantics.c:8630 +#: cp/semantics.c:7822 cp/semantics.c:8644 #, gcc-internal-format msgid "temporary of non-literal type %qT in a constant expression" msgstr "" -#: cp/semantics.c:8087 cp/semantics.c:8534 cp/semantics.c:8794 +#: cp/semantics.c:8089 cp/semantics.c:8536 cp/semantics.c:8811 #, gcc-internal-format msgid "expression %qE is not a constant-expression" msgstr "" -#: cp/semantics.c:8092 +#: cp/semantics.c:8094 #, gcc-internal-format msgid "unexpected expression %qE of kind %s" msgstr "" -#: cp/semantics.c:8124 +#: cp/semantics.c:8126 #, gcc-internal-format msgid "" "%qT cannot be the type of a complete constant expression because it has " "mutable sub-objects" msgstr "" -#: cp/semantics.c:8137 +#: cp/semantics.c:8139 #, gcc-internal-format msgid "" "conversion from pointer type %qT to arithmetic type %qT in a constant-" "expression" msgstr "" -#: cp/semantics.c:8308 +#: cp/semantics.c:8310 #, gcc-internal-format msgid "expression %qE has side-effects" msgstr "" -#: cp/semantics.c:8378 +#: cp/semantics.c:8380 #, gcc-internal-format msgid "" "calling a member function of the object being constructed in a constant " "expression" msgstr "" -#: cp/semantics.c:8460 +#: cp/semantics.c:8462 #, gcc-internal-format msgid "" "address-of an object %qE with thread local or automatic storage is not a " "constant expression" msgstr "" -#: cp/semantics.c:8546 +#: cp/semantics.c:8548 #, gcc-internal-format msgid "" "typeid-expression is not a constant expression because %qE is of polymorphic " "type" msgstr "" -#: cp/semantics.c:8559 +#: cp/semantics.c:8561 #, gcc-internal-format msgid "difference of two pointer expressions is not a constant expression" msgstr "" -#: cp/semantics.c:8578 +#: cp/semantics.c:8580 #, gcc-internal-format msgid "pointer comparison expression is not a constant expression" msgstr "" -#: cp/semantics.c:8679 +#: cp/semantics.c:8619 +#, gcc-internal-format +msgid "cast to non-integral type %qT in a constant expression" +msgstr "" + +#: cp/semantics.c:8695 #, gcc-internal-format msgid "division by zero is not a constant-expression" msgstr "" -#: cp/semantics.c:8802 +#: cp/semantics.c:8819 #, gcc-internal-format msgid "non-constant array initialization" msgstr "" -#: cp/semantics.c:8811 +#: cp/semantics.c:8828 #, gcc-internal-format, gfc-internal-format msgid "unexpected AST of kind %s" msgstr "" -#: cp/semantics.c:9303 +#: cp/semantics.c:9320 #, gcc-internal-format msgid "cannot capture %qE by reference" msgstr "" -#: cp/semantics.c:9326 +#: cp/semantics.c:9343 #, gcc-internal-format msgid "already captured %qD in lambda expression" msgstr "" -#: cp/semantics.c:9472 +#: cp/semantics.c:9515 #, gcc-internal-format msgid "%<this%> was not captured for this lambda function" msgstr "" @@ -36338,83 +36381,83 @@ msgstr "" msgid "%qV qualifiers cannot be applied to %qT" msgstr "" -#: cp/tree.c:3084 +#: cp/tree.c:3078 #, gcc-internal-format msgid "%qE attribute can only be applied to Java class definitions" msgstr "" -#: cp/tree.c:3113 +#: cp/tree.c:3107 #, gcc-internal-format msgid "%qE attribute can only be applied to class definitions" msgstr "" -#: cp/tree.c:3119 +#: cp/tree.c:3113 #, gcc-internal-format msgid "%qE is obsolete; g++ vtables are now COM-compatible by default" msgstr "" -#: cp/tree.c:3143 +#: cp/tree.c:3137 #, gcc-internal-format msgid "requested init_priority is not an integer constant" msgstr "" -#: cp/tree.c:3164 +#: cp/tree.c:3158 #, gcc-internal-format msgid "" "can only use %qE attribute on file-scope definitions of objects of class type" msgstr "" -#: cp/tree.c:3172 +#: cp/tree.c:3166 #, gcc-internal-format msgid "requested init_priority is out of range" msgstr "" -#: cp/tree.c:3182 +#: cp/tree.c:3176 #, gcc-internal-format msgid "requested init_priority is reserved for internal use" msgstr "" -#: cp/tree.c:3193 +#: cp/tree.c:3187 #, gcc-internal-format msgid "%qE attribute is not supported on this platform" msgstr "" -#: cp/tree.c:3220 +#: cp/tree.c:3214 #, gcc-internal-format msgid "redeclaration of %qD adds abi tag %E" msgstr "" -#: cp/tree.c:3226 +#: cp/tree.c:3220 #, gcc-internal-format msgid "previous declaration here" msgstr "" -#: cp/tree.c:3243 +#: cp/tree.c:3237 #, gcc-internal-format msgid "%qE attribute applied to non-class, non-enum type %qT" msgstr "" -#: cp/tree.c:3249 +#: cp/tree.c:3243 #, gcc-internal-format msgid "%qE attribute applied to %qT after its definition" msgstr "" -#: cp/tree.c:3271 +#: cp/tree.c:3265 #, gcc-internal-format msgid "%qE attribute applied to non-function %qD" msgstr "" -#: cp/tree.c:3276 +#: cp/tree.c:3270 #, gcc-internal-format msgid "%qE attribute applied to extern \"C\" function %qD" msgstr "" -#: cp/tree.c:3977 +#: cp/tree.c:3971 #, gcc-internal-format msgid "zero as null pointer constant" msgstr "" -#: cp/tree.c:3990 +#: cp/tree.c:3984 #, gcc-internal-format, gfc-internal-format msgid "lang_* check: failed in %s, at %s:%d" msgstr "" @@ -37199,17 +37242,22 @@ msgid "returning a value from a constructor" msgstr "" #. Give a helpful error message. -#: cp/typeck.c:8133 cp/typeck.c:8172 +#: cp/typeck.c:8133 cp/typeck.c:8177 #, gcc-internal-format msgid "return-statement with no value, in function returning %qT" msgstr "" -#: cp/typeck.c:8191 +#: cp/typeck.c:8141 +#, gcc-internal-format +msgid "returning initializer list" +msgstr "" + +#: cp/typeck.c:8196 #, gcc-internal-format msgid "return-statement with a value, in function returning 'void'" msgstr "" -#: cp/typeck.c:8221 +#: cp/typeck.c:8226 #, gcc-internal-format msgid "" "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -" @@ -37217,12 +37265,12 @@ msgid "" msgstr "" #. Make this a permerror because we used to accept it. -#: cp/typeck.c:8789 +#: cp/typeck.c:8794 #, gcc-internal-format msgid "using temporary as lvalue" msgstr "" -#: cp/typeck.c:8791 +#: cp/typeck.c:8796 #, gcc-internal-format msgid "using xvalue (rvalue reference) as lvalue" msgstr "" @@ -37740,73 +37788,73 @@ msgstr "" msgid "DO-iterator '%s' at %L is inside iterator of the same name" msgstr "" -#: fortran/array.c:1010 fortran/array.c:1143 +#: fortran/array.c:1010 fortran/array.c:1154 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in array constructor at %C" msgstr "" -#: fortran/array.c:1062 +#: fortran/array.c:1063 #, gcc-internal-format, gfc-internal-format msgid "[...] style array constructors at %C" msgstr "" -#: fortran/array.c:1083 +#: fortran/array.c:1085 #, gcc-internal-format, gfc-internal-format msgid "Array constructor including type specification at %C" msgstr "" -#: fortran/array.c:1089 fortran/match.c:3469 +#: fortran/array.c:1094 fortran/match.c:3469 #, gcc-internal-format, gfc-internal-format msgid "Type-spec at %L cannot contain a deferred type parameter" msgstr "" -#: fortran/array.c:1105 +#: fortran/array.c:1116 #, gcc-internal-format, gfc-internal-format msgid "Empty array constructor at %C is not allowed" msgstr "" -#: fortran/array.c:1190 +#: fortran/array.c:1201 #, gcc-internal-format, gfc-internal-format msgid "Element in %s array constructor at %L is %s" msgstr "" -#: fortran/array.c:1518 +#: fortran/array.c:1529 #, gcc-internal-format, gfc-internal-format msgid "Iterator step at %L cannot be zero" msgstr "" #. Problems occur when we get something like #. integer :: a(lots) = (/(i, i=1, lots)/) -#: fortran/array.c:1655 fortran/expr.c:1535 fortran/trans-array.c:5370 +#: fortran/array.c:1666 fortran/expr.c:1535 fortran/trans-array.c:5370 #, gcc-internal-format, gfc-internal-format msgid "" "The number of elements in the array constructor at %L requires an increase " "of the allowed %d upper limit. See -fmax-array-constructor option" msgstr "" -#: fortran/array.c:1826 +#: fortran/array.c:1837 #, gcc-internal-format, gfc-internal-format msgid "AC-IMPLIED-DO initial expression references control variable at %L" msgstr "" -#: fortran/array.c:1833 +#: fortran/array.c:1844 #, gcc-internal-format, gfc-internal-format msgid "AC-IMPLIED-DO final expression references control variable at %L" msgstr "" -#: fortran/array.c:1840 +#: fortran/array.c:1851 #, gcc-internal-format, gfc-internal-format msgid "AC-IMPLIED-DO step expression references control variable at %L" msgstr "" -#: fortran/array.c:1852 +#: fortran/array.c:1863 #, gcc-internal-format, gfc-internal-format msgid "" "Array constructor value at %L shall not be unlimited polymorphic [F2008: " "C4106]" msgstr "" -#: fortran/array.c:1935 +#: fortran/array.c:1946 #, gcc-internal-format, gfc-internal-format msgid "Different CHARACTER lengths (%d/%d) in array constructor at %L" msgstr "" @@ -39202,7 +39250,7 @@ msgstr "" #: fortran/decl.c:5300 fortran/decl.c:5304 fortran/decl.c:5508 #: fortran/decl.c:5512 fortran/decl.c:5698 fortran/decl.c:5702 -#: fortran/symbol.c:1588 +#: fortran/symbol.c:1577 #, gcc-internal-format, gfc-internal-format msgid "BIND(C) attribute at %L can only be used for variables or common blocks" msgstr "" @@ -40351,85 +40399,85 @@ msgid "" "Procedure pointer initialization target at %L may not be a procedure pointer" msgstr "" -#: fortran/expr.c:4692 +#: fortran/expr.c:4693 #, gcc-internal-format, gfc-internal-format msgid "" "Fortran 2008: Pointer functions in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4700 +#: fortran/expr.c:4701 #, gcc-internal-format, gfc-internal-format msgid "Non-variable expression in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4708 +#: fortran/expr.c:4709 #, gcc-internal-format, gfc-internal-format msgid "Named constant '%s' in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4717 +#: fortran/expr.c:4718 #, gcc-internal-format, gfc-internal-format msgid "'%s' in variable definition context (%s) at %L is not a variable" msgstr "" -#: fortran/expr.c:4728 +#: fortran/expr.c:4729 #, gcc-internal-format, gfc-internal-format msgid "Non-POINTER in pointer association context (%s) at %L" msgstr "" -#: fortran/expr.c:4741 +#: fortran/expr.c:4742 #, gcc-internal-format, gfc-internal-format msgid "LOCK_TYPE in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4770 +#: fortran/expr.c:4771 #, gcc-internal-format, gfc-internal-format msgid "" "Dummy argument '%s' with INTENT(IN) in pointer association context (%s) at %L" msgstr "" -#: fortran/expr.c:4778 +#: fortran/expr.c:4779 #, gcc-internal-format, gfc-internal-format msgid "" "Dummy argument '%s' with INTENT(IN) in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4791 +#: fortran/expr.c:4792 #, gcc-internal-format, gfc-internal-format msgid "" "Variable '%s' is PROTECTED and can not appear in a pointer association " "context (%s) at %L" msgstr "" -#: fortran/expr.c:4799 +#: fortran/expr.c:4800 #, gcc-internal-format, gfc-internal-format msgid "" "Variable '%s' is PROTECTED and can not appear in a variable definition " "context (%s) at %L" msgstr "" -#: fortran/expr.c:4811 +#: fortran/expr.c:4812 #, gcc-internal-format, gfc-internal-format msgid "" "Variable '%s' can not appear in a variable definition context (%s) at %L in " "PURE procedure" msgstr "" -#: fortran/expr.c:4870 +#: fortran/expr.c:4871 #, gcc-internal-format, gfc-internal-format msgid "" "'%s' at %L associated to vector-indexed target can not be used in a variable " "definition context (%s)" msgstr "" -#: fortran/expr.c:4874 +#: fortran/expr.c:4875 #, gcc-internal-format, gfc-internal-format msgid "" "'%s' at %L associated to expression can not be used in a variable definition " "context (%s)" msgstr "" -#: fortran/expr.c:4886 +#: fortran/expr.c:4887 #, gcc-internal-format, gfc-internal-format msgid "" "Associate-name '%s' can not appear in a variable definition context (%s) at " @@ -40443,7 +40491,7 @@ msgstr "" #: fortran/frontend-passes.c:518 fortran/trans-array.c:1041 #: fortran/trans-array.c:5866 fortran/trans-array.c:7150 -#: fortran/trans-intrinsic.c:5445 +#: fortran/trans-intrinsic.c:5444 #, gcc-internal-format, gfc-internal-format msgid "Creating array temporary at %L" msgstr "" @@ -40590,12 +40638,12 @@ msgstr "" msgid "Second argument of defined assignment at %L must be INTENT(IN)" msgstr "" -#: fortran/interface.c:723 fortran/resolve.c:14797 +#: fortran/interface.c:723 fortran/resolve.c:14799 #, gcc-internal-format, gfc-internal-format msgid "First argument of operator interface at %L must be INTENT(IN)" msgstr "" -#: fortran/interface.c:730 fortran/resolve.c:14815 +#: fortran/interface.c:730 fortran/resolve.c:14817 #, gcc-internal-format, gfc-internal-format msgid "Second argument of operator interface at %L must be INTENT(IN)" msgstr "" @@ -41654,7 +41702,7 @@ msgid "Expected expression in %s statement at %C" msgstr "" #. A general purpose syntax error. -#: fortran/io.c:3175 fortran/io.c:3774 fortran/gfortran.h:2496 +#: fortran/io.c:3175 fortran/io.c:3774 fortran/gfortran.h:2506 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in %s statement at %C" msgstr "" @@ -44419,7 +44467,7 @@ msgstr "" msgid "Unable to resolve the specific function '%s' at %L" msgstr "" -#: fortran/resolve.c:2630 fortran/resolve.c:14732 +#: fortran/resolve.c:2630 fortran/resolve.c:14734 #, gcc-internal-format, gfc-internal-format msgid "Function '%s' at %L has no IMPLICIT type" msgstr "" @@ -45965,43 +46013,43 @@ msgstr "" msgid "Component '%s' with CLASS at %L must be allocatable or pointer" msgstr "" -#: fortran/resolve.c:12934 +#: fortran/resolve.c:12936 #, gcc-internal-format, gfc-internal-format msgid "" "Generic name '%s' of function '%s' at %L being the same name as derived type " "at %L" msgstr "" -#: fortran/resolve.c:12990 +#: fortran/resolve.c:12992 #, gcc-internal-format, gfc-internal-format msgid "Assumed size array '%s' in namelist '%s' at %L is not allowed" msgstr "" -#: fortran/resolve.c:12996 +#: fortran/resolve.c:12998 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST array object '%s' with assumed shape in namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13003 +#: fortran/resolve.c:13005 #, gcc-internal-format, gfc-internal-format msgid "" "NAMELIST array object '%s' with nonconstant shape in namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13012 +#: fortran/resolve.c:13014 #, gcc-internal-format, gfc-internal-format msgid "" "NAMELIST object '%s' with nonconstant character length in namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13022 +#: fortran/resolve.c:13024 #, gcc-internal-format, gfc-internal-format msgid "" "NAMELIST object '%s' in namelist '%s' at %L is polymorphic and requires a " "defined input/output procedure" msgstr "" -#: fortran/resolve.c:13032 +#: fortran/resolve.c:13034 #, gcc-internal-format, gfc-internal-format msgid "" "NAMELIST object '%s' in namelist '%s' at %L with ALLOCATABLE or POINTER " @@ -46010,416 +46058,416 @@ msgstr "" #. FIXME: Once UDDTIO is implemented, the following can be #. removed. -#: fortran/resolve.c:13040 +#: fortran/resolve.c:13042 #, gcc-internal-format, gfc-internal-format msgid "" "NAMELIST object '%s' in namelist '%s' at %L has ALLOCATABLE or POINTER " "components and thus requires a defined input/output procedure" msgstr "" -#: fortran/resolve.c:13057 +#: fortran/resolve.c:13059 #, gcc-internal-format, gfc-internal-format msgid "" "NAMELIST object '%s' was declared PRIVATE and cannot be member of PUBLIC " "namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13067 +#: fortran/resolve.c:13069 #, gcc-internal-format, gfc-internal-format msgid "" "NAMELIST object '%s' has use-associated PRIVATE components and cannot be " "member of namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13078 +#: fortran/resolve.c:13080 #, gcc-internal-format, gfc-internal-format msgid "" "NAMELIST object '%s' has PRIVATE components and cannot be a member of PUBLIC " "namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13105 +#: fortran/resolve.c:13107 #, gcc-internal-format, gfc-internal-format msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L" msgstr "" -#: fortran/resolve.c:13124 +#: fortran/resolve.c:13126 #, gcc-internal-format, gfc-internal-format msgid "Parameter array '%s' at %L cannot be automatic or of deferred shape" msgstr "" -#: fortran/resolve.c:13136 +#: fortran/resolve.c:13138 #, gcc-internal-format, gfc-internal-format msgid "" "Implicitly typed PARAMETER '%s' at %L doesn't match a later IMPLICIT type" msgstr "" -#: fortran/resolve.c:13147 +#: fortran/resolve.c:13149 #, gcc-internal-format, gfc-internal-format msgid "Incompatible derived type in PARAMETER at %L" msgstr "" -#: fortran/resolve.c:13230 +#: fortran/resolve.c:13232 #, gcc-internal-format, gfc-internal-format msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L" msgstr "" -#: fortran/resolve.c:13233 +#: fortran/resolve.c:13235 #, gcc-internal-format, gfc-internal-format msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L" msgstr "" -#: fortran/resolve.c:13322 +#: fortran/resolve.c:13324 #, gcc-internal-format, gfc-internal-format msgid "" "'%s' at %L has the CONTIGUOUS attribute but is not an array pointer or an " "assumed-shape or assumed-rank array" msgstr "" -#: fortran/resolve.c:13340 +#: fortran/resolve.c:13342 #, gcc-internal-format, gfc-internal-format msgid "Assumed size array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.c:13343 +#: fortran/resolve.c:13345 #, gcc-internal-format, gfc-internal-format msgid "Assumed shape array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.c:13351 +#: fortran/resolve.c:13353 #, gcc-internal-format, gfc-internal-format msgid "Assumed-rank array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.c:13358 +#: fortran/resolve.c:13360 #, gcc-internal-format, gfc-internal-format msgid "" "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute" msgstr "" -#: fortran/resolve.c:13371 +#: fortran/resolve.c:13373 #, gcc-internal-format, gfc-internal-format msgid "Symbol at %L is not a DUMMY variable" msgstr "" -#: fortran/resolve.c:13377 +#: fortran/resolve.c:13379 #, gcc-internal-format, gfc-internal-format msgid "" "'%s' at %L cannot have the VALUE attribute because it is not a dummy argument" msgstr "" -#: fortran/resolve.c:13387 +#: fortran/resolve.c:13389 #, gcc-internal-format, gfc-internal-format msgid "" "Character dummy variable '%s' at %L with VALUE attribute must have constant " "length" msgstr "" -#: fortran/resolve.c:13396 +#: fortran/resolve.c:13398 #, gcc-internal-format, gfc-internal-format msgid "" "C interoperable character dummy variable '%s' at %L with VALUE attribute " "must have length one" msgstr "" -#: fortran/resolve.c:13409 fortran/resolve.c:13522 +#: fortran/resolve.c:13411 fortran/resolve.c:13524 #, gcc-internal-format, gfc-internal-format msgid "The derived type '%s' at %L is of type '%s', which has not been defined" msgstr "" -#: fortran/resolve.c:13422 +#: fortran/resolve.c:13424 #, gcc-internal-format, gfc-internal-format msgid "Assumed type of variable %s at %L is only permitted for dummy variables" msgstr "" -#: fortran/resolve.c:13429 +#: fortran/resolve.c:13431 #, gcc-internal-format, gfc-internal-format msgid "" "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, " "POINTER or VALUE attribute" msgstr "" -#: fortran/resolve.c:13436 +#: fortran/resolve.c:13438 #, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute" msgstr "" -#: fortran/resolve.c:13443 +#: fortran/resolve.c:13445 #, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L shall not be an explicit-shape array" msgstr "" -#: fortran/resolve.c:13468 +#: fortran/resolve.c:13470 #, gcc-internal-format, gfc-internal-format msgid "" "Variable '%s' at %L cannot be BIND(C) because it is neither a COMMON block " "nor declared at the module level scope" msgstr "" -#: fortran/resolve.c:13548 +#: fortran/resolve.c:13550 #, gcc-internal-format, gfc-internal-format msgid "PUBLIC %s '%s' at %L of PRIVATE derived type '%s'" msgstr "" -#: fortran/resolve.c:13562 +#: fortran/resolve.c:13564 #, gcc-internal-format, gfc-internal-format msgid "" "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE " "must be a coarray" msgstr "" -#: fortran/resolve.c:13580 +#: fortran/resolve.c:13582 #, gcc-internal-format, gfc-internal-format msgid "" "The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have " "a default initializer" msgstr "" -#: fortran/resolve.c:13592 +#: fortran/resolve.c:13594 #, gcc-internal-format, gfc-internal-format msgid "Dummy argument '%s' at %L of LOCK_TYPE shall not be INTENT(OUT)" msgstr "" -#: fortran/resolve.c:13604 +#: fortran/resolve.c:13606 #, gcc-internal-format, gfc-internal-format msgid "" "Function result '%s' at %L shall not be a coarray or have a coarray component" msgstr "" -#: fortran/resolve.c:13613 +#: fortran/resolve.c:13615 #, gcc-internal-format, gfc-internal-format msgid "" "Variable '%s' at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray" msgstr "" -#: fortran/resolve.c:13625 +#: fortran/resolve.c:13627 #, gcc-internal-format, gfc-internal-format msgid "" "Variable '%s' at %L with coarray component shall be a nonpointer, " "nonallocatable scalar" msgstr "" -#: fortran/resolve.c:13640 +#: fortran/resolve.c:13642 #, gcc-internal-format, gfc-internal-format msgid "" "Variable '%s' at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy " "argument" msgstr "" -#: fortran/resolve.c:13648 +#: fortran/resolve.c:13650 #, gcc-internal-format, gfc-internal-format msgid "" "Coarray variable '%s' at %L shall not have codimensions with deferred shape" msgstr "" -#: fortran/resolve.c:13655 +#: fortran/resolve.c:13657 #, gcc-internal-format, gfc-internal-format msgid "Allocatable coarray variable '%s' at %L must have deferred shape" msgstr "" -#: fortran/resolve.c:13667 +#: fortran/resolve.c:13669 #, gcc-internal-format, gfc-internal-format msgid "" "Variable '%s' at %L is INTENT(OUT) and can thus not be an allocatable " "coarray or have coarray components" msgstr "" -#: fortran/resolve.c:13676 +#: fortran/resolve.c:13678 #, gcc-internal-format, gfc-internal-format msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'" msgstr "" -#: fortran/resolve.c:13692 +#: fortran/resolve.c:13694 #, gcc-internal-format, gfc-internal-format msgid "" "LOGICAL dummy argument '%s' at %L with non-C_Bool kind in BIND(C) procedure " "'%s'" msgstr "" -#: fortran/resolve.c:13698 +#: fortran/resolve.c:13700 #, gcc-internal-format, gfc-internal-format msgid "" "LOGICAL result variable '%s' at %L with non-C_Bool kind in BIND(C) procedure " "'%s'" msgstr "" -#: fortran/resolve.c:13778 +#: fortran/resolve.c:13780 #, gcc-internal-format, gfc-internal-format msgid "Threadprivate at %L isn't SAVEd" msgstr "" -#: fortran/resolve.c:13871 +#: fortran/resolve.c:13873 #, gcc-internal-format, gfc-internal-format msgid "BLOCK DATA element '%s' at %L must be in COMMON" msgstr "" -#: fortran/resolve.c:13877 +#: fortran/resolve.c:13879 #, gcc-internal-format, gfc-internal-format msgid "DATA array '%s' at %L must be specified in a previous declaration" msgstr "" -#: fortran/resolve.c:13886 +#: fortran/resolve.c:13888 #, gcc-internal-format, gfc-internal-format msgid "DATA element '%s' at %L cannot have a coindex" msgstr "" -#: fortran/resolve.c:13900 +#: fortran/resolve.c:13902 #, gcc-internal-format, gfc-internal-format msgid "DATA element '%s' at %L is a pointer and so must be a full array" msgstr "" -#: fortran/resolve.c:13946 +#: fortran/resolve.c:13948 #, gcc-internal-format, gfc-internal-format msgid "Nonconstant array section at %L in DATA statement" msgstr "" -#: fortran/resolve.c:13959 +#: fortran/resolve.c:13961 #, gcc-internal-format, gfc-internal-format msgid "DATA statement at %L has more variables than values" msgstr "" -#: fortran/resolve.c:14058 +#: fortran/resolve.c:14060 #, gcc-internal-format, gfc-internal-format msgid "" "start of implied-do loop at %L could not be simplified to a constant value" msgstr "" -#: fortran/resolve.c:14066 +#: fortran/resolve.c:14068 #, gcc-internal-format, gfc-internal-format msgid "" "end of implied-do loop at %L could not be simplified to a constant value" msgstr "" -#: fortran/resolve.c:14074 +#: fortran/resolve.c:14076 #, gcc-internal-format, gfc-internal-format msgid "" "step of implied-do loop at %L could not be simplified to a constant value" msgstr "" -#: fortran/resolve.c:14199 +#: fortran/resolve.c:14201 #, gcc-internal-format, gfc-internal-format msgid "DATA statement at %L has more values than variables" msgstr "" -#: fortran/resolve.c:14337 +#: fortran/resolve.c:14339 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %L defined but not used" msgstr "" -#: fortran/resolve.c:14342 +#: fortran/resolve.c:14344 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %L defined but cannot be used" msgstr "" -#: fortran/resolve.c:14426 +#: fortran/resolve.c:14428 #, gcc-internal-format, gfc-internal-format msgid "" "Derived type variable '%s' at %L must have SEQUENCE attribute to be an " "EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14435 +#: fortran/resolve.c:14437 #, gcc-internal-format, gfc-internal-format msgid "" "Derived type variable '%s' at %L cannot have ALLOCATABLE components to be an " "EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14443 +#: fortran/resolve.c:14445 #, gcc-internal-format, gfc-internal-format msgid "" "Derived type variable '%s' at %L with default initialization cannot be in " "EQUIVALENCE with a variable in COMMON" msgstr "" -#: fortran/resolve.c:14459 +#: fortran/resolve.c:14461 #, gcc-internal-format, gfc-internal-format msgid "" "Derived type variable '%s' at %L with pointer component(s) cannot be an " "EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14562 +#: fortran/resolve.c:14564 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in EQUIVALENCE statement at %L" msgstr "" -#: fortran/resolve.c:14577 +#: fortran/resolve.c:14579 #, gcc-internal-format, gfc-internal-format msgid "" "Either all or none of the objects in the EQUIVALENCE set at %L shall have " "the PROTECTED attribute" msgstr "" -#: fortran/resolve.c:14589 +#: fortran/resolve.c:14591 #, gcc-internal-format, gfc-internal-format msgid "" "Common block member '%s' at %L cannot be an EQUIVALENCE object in the pure " "procedure '%s'" msgstr "" -#: fortran/resolve.c:14598 +#: fortran/resolve.c:14600 #, gcc-internal-format, gfc-internal-format msgid "Named constant '%s' at %L cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14677 +#: fortran/resolve.c:14679 #, gcc-internal-format, gfc-internal-format msgid "" "Array '%s' at %L with non-constant bounds cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14688 +#: fortran/resolve.c:14690 #, gcc-internal-format, gfc-internal-format msgid "Structure component '%s' at %L cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14699 +#: fortran/resolve.c:14701 #, gcc-internal-format, gfc-internal-format msgid "Substring at %L has length zero" msgstr "" -#: fortran/resolve.c:14742 +#: fortran/resolve.c:14744 #, gcc-internal-format, gfc-internal-format msgid "PUBLIC function '%s' at %L of PRIVATE type '%s'" msgstr "" -#: fortran/resolve.c:14755 +#: fortran/resolve.c:14757 #, gcc-internal-format, gfc-internal-format msgid "ENTRY '%s' at %L has no IMPLICIT type" msgstr "" -#: fortran/resolve.c:14772 +#: fortran/resolve.c:14774 #, gcc-internal-format, gfc-internal-format msgid "User operator procedure '%s' at %L must be a FUNCTION" msgstr "" -#: fortran/resolve.c:14782 +#: fortran/resolve.c:14784 #, gcc-internal-format, gfc-internal-format msgid "User operator procedure '%s' at %L cannot be assumed character length" msgstr "" -#: fortran/resolve.c:14790 +#: fortran/resolve.c:14792 #, gcc-internal-format, gfc-internal-format msgid "User operator procedure '%s' at %L must have at least one argument" msgstr "" -#: fortran/resolve.c:14804 +#: fortran/resolve.c:14806 #, gcc-internal-format, gfc-internal-format msgid "First argument of operator interface at %L cannot be optional" msgstr "" -#: fortran/resolve.c:14822 +#: fortran/resolve.c:14824 #, gcc-internal-format, gfc-internal-format msgid "Second argument of operator interface at %L cannot be optional" msgstr "" -#: fortran/resolve.c:14829 +#: fortran/resolve.c:14831 #, gcc-internal-format, gfc-internal-format msgid "Operator interface at %L must have, at most, two arguments" msgstr "" -#: fortran/resolve.c:14905 +#: fortran/resolve.c:14907 #, gcc-internal-format, gfc-internal-format msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE" msgstr "" @@ -46693,33 +46741,33 @@ msgid "" "Character '%s' in string at %L cannot be converted into character kind %d" msgstr "" -#: fortran/symbol.c:134 +#: fortran/symbol.c:123 #, gcc-internal-format, gfc-internal-format msgid "Duplicate IMPLICIT NONE statement at %C" msgstr "" -#: fortran/symbol.c:174 +#: fortran/symbol.c:163 #, gcc-internal-format, gfc-internal-format msgid "Letter '%c' already set in IMPLICIT statement at %C" msgstr "" -#: fortran/symbol.c:196 +#: fortran/symbol.c:185 #, gcc-internal-format, gfc-internal-format msgid "Cannot specify IMPLICIT at %C after IMPLICIT NONE" msgstr "" -#: fortran/symbol.c:206 +#: fortran/symbol.c:195 #, gcc-internal-format, gfc-internal-format msgid "Letter %c already has an IMPLICIT type at %C" msgstr "" -#: fortran/symbol.c:262 +#: fortran/symbol.c:251 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L has no IMPLICIT type" msgstr "" #. BIND(C) variables should not be implicitly declared. -#: fortran/symbol.c:279 +#: fortran/symbol.c:268 #, gcc-internal-format, gfc-internal-format msgid "" "Implicitly declared BIND(C) variable '%s' at %L may not be C interoperable" @@ -46727,312 +46775,312 @@ msgstr "" #. Dummy args to a BIND(C) routine may not be interoperable if #. they are implicitly typed. -#: fortran/symbol.c:294 +#: fortran/symbol.c:283 #, gcc-internal-format, gfc-internal-format msgid "" "Implicitly declared variable '%s' at %L may not be C interoperable but it is " "a dummy argument to the BIND(C) procedure '%s' at %L" msgstr "" -#: fortran/symbol.c:335 +#: fortran/symbol.c:324 #, gcc-internal-format, gfc-internal-format msgid "Function result '%s' at %L has no IMPLICIT type" msgstr "" -#: fortran/symbol.c:424 +#: fortran/symbol.c:413 #, gcc-internal-format, gfc-internal-format msgid "%s attribute not allowed in BLOCK DATA program unit at %L" msgstr "" -#: fortran/symbol.c:448 +#: fortran/symbol.c:437 #, gcc-internal-format, gfc-internal-format msgid "Namelist group name at %L cannot have the SAVE attribute" msgstr "" -#: fortran/symbol.c:482 +#: fortran/symbol.c:471 #, gcc-internal-format, gfc-internal-format msgid "Procedure pointer at %C" msgstr "" -#: fortran/symbol.c:644 +#: fortran/symbol.c:633 #, gcc-internal-format, gfc-internal-format msgid "%s attribute applied to %s %s at %L" msgstr "" -#: fortran/symbol.c:651 +#: fortran/symbol.c:640 #, gcc-internal-format, gfc-internal-format msgid "BIND(C) applied to %s %s at %L" msgstr "" -#: fortran/symbol.c:762 fortran/symbol.c:1485 +#: fortran/symbol.c:751 fortran/symbol.c:1474 #, gcc-internal-format, gfc-internal-format msgid "%s attribute conflicts with %s attribute at %L" msgstr "" -#: fortran/symbol.c:765 +#: fortran/symbol.c:754 #, gcc-internal-format, gfc-internal-format msgid "%s attribute conflicts with %s attribute in '%s' at %L" msgstr "" -#: fortran/symbol.c:773 +#: fortran/symbol.c:762 #, gcc-internal-format, gfc-internal-format msgid "%s attribute with %s attribute at %L" msgstr "" -#: fortran/symbol.c:779 +#: fortran/symbol.c:768 #, gcc-internal-format, gfc-internal-format msgid "%s attribute with %s attribute in '%s' at %L" msgstr "" -#: fortran/symbol.c:823 +#: fortran/symbol.c:812 #, gcc-internal-format, gfc-internal-format msgid "Cannot change attributes of USE-associated symbol at %L" msgstr "" -#: fortran/symbol.c:826 +#: fortran/symbol.c:815 #, gcc-internal-format, gfc-internal-format msgid "Cannot change attributes of USE-associated symbol %s at %L" msgstr "" -#: fortran/symbol.c:842 +#: fortran/symbol.c:831 #, gcc-internal-format, gfc-internal-format msgid "Duplicate %s attribute specified at %L" msgstr "" -#: fortran/symbol.c:884 +#: fortran/symbol.c:873 #, gcc-internal-format, gfc-internal-format msgid "ALLOCATABLE specified outside of INTERFACE body at %L" msgstr "" -#: fortran/symbol.c:910 +#: fortran/symbol.c:899 #, gcc-internal-format, gfc-internal-format msgid "CODIMENSION specified for '%s' outside its INTERFACE body at %L" msgstr "" -#: fortran/symbol.c:936 +#: fortran/symbol.c:925 #, gcc-internal-format, gfc-internal-format msgid "DIMENSION specified for '%s' outside its INTERFACE body at %L" msgstr "" -#: fortran/symbol.c:1066 +#: fortran/symbol.c:1055 #, gcc-internal-format, gfc-internal-format msgid "Cray Pointee at %L appears in multiple pointer() statements" msgstr "" -#: fortran/symbol.c:1085 +#: fortran/symbol.c:1074 #, gcc-internal-format, gfc-internal-format msgid "Duplicate PROTECTED attribute specified at %L" msgstr "" -#: fortran/symbol.c:1119 +#: fortran/symbol.c:1108 #, gcc-internal-format, gfc-internal-format msgid "SAVE attribute at %L cannot be specified in a PURE procedure" msgstr "" -#: fortran/symbol.c:1130 +#: fortran/symbol.c:1119 #, gcc-internal-format, gfc-internal-format msgid "Duplicate SAVE attribute specified at %L" msgstr "" -#: fortran/symbol.c:1151 +#: fortran/symbol.c:1140 #, gcc-internal-format, gfc-internal-format msgid "Duplicate VALUE attribute specified at %L" msgstr "" -#: fortran/symbol.c:1171 +#: fortran/symbol.c:1160 #, gcc-internal-format, gfc-internal-format msgid "Duplicate VOLATILE attribute specified at %L" msgstr "" -#: fortran/symbol.c:1190 +#: fortran/symbol.c:1179 #, gcc-internal-format, gfc-internal-format msgid "Duplicate ASYNCHRONOUS attribute specified at %L" msgstr "" -#: fortran/symbol.c:1481 +#: fortran/symbol.c:1470 #, gcc-internal-format, gfc-internal-format msgid "%s attribute of '%s' conflicts with %s attribute at %L" msgstr "" -#: fortran/symbol.c:1515 +#: fortran/symbol.c:1504 #, gcc-internal-format, gfc-internal-format msgid "%s procedure at %L is already declared as %s procedure" msgstr "" -#: fortran/symbol.c:1550 +#: fortran/symbol.c:1539 #, gcc-internal-format, gfc-internal-format msgid "INTENT (%s) conflicts with INTENT(%s) at %L" msgstr "" -#: fortran/symbol.c:1574 +#: fortran/symbol.c:1563 #, gcc-internal-format, gfc-internal-format msgid "ACCESS specification at %L was already specified" msgstr "" -#: fortran/symbol.c:1591 +#: fortran/symbol.c:1580 #, gcc-internal-format, gfc-internal-format msgid "Duplicate BIND attribute specified at %L" msgstr "" -#: fortran/symbol.c:1598 +#: fortran/symbol.c:1587 #, gcc-internal-format, gfc-internal-format msgid "BIND(C) at %L" msgstr "" -#: fortran/symbol.c:1615 +#: fortran/symbol.c:1604 #, gcc-internal-format, gfc-internal-format msgid "Duplicate EXTENDS attribute specified at %L" msgstr "" -#: fortran/symbol.c:1619 +#: fortran/symbol.c:1608 #, gcc-internal-format, gfc-internal-format msgid "EXTENDS at %L" msgstr "" -#: fortran/symbol.c:1641 +#: fortran/symbol.c:1630 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L already has an explicit interface" msgstr "" -#: fortran/symbol.c:1648 +#: fortran/symbol.c:1637 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L has attributes specified outside its INTERFACE body" msgstr "" -#: fortran/symbol.c:1682 +#: fortran/symbol.c:1671 #, gcc-internal-format, gfc-internal-format msgid "" "Symbol '%s' at %L conflicts with symbol from module '%s', use-associated at " "%L" msgstr "" -#: fortran/symbol.c:1686 +#: fortran/symbol.c:1675 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L already has basic type of %s" msgstr "" -#: fortran/symbol.c:1693 +#: fortran/symbol.c:1682 #, gcc-internal-format, gfc-internal-format msgid "Procedure '%s' at %L may not have basic type of %s" msgstr "" -#: fortran/symbol.c:1705 +#: fortran/symbol.c:1694 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L cannot have a type" msgstr "" -#: fortran/symbol.c:1874 +#: fortran/symbol.c:1863 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' at %C already declared at %L" msgstr "" -#: fortran/symbol.c:1885 +#: fortran/symbol.c:1874 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' at %C already in the parent type at %L" msgstr "" -#: fortran/symbol.c:1970 +#: fortran/symbol.c:1959 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %C is ambiguous" msgstr "" -#: fortran/symbol.c:2002 +#: fortran/symbol.c:1991 #, gcc-internal-format, gfc-internal-format msgid "Derived type '%s' at %C is being used before it is defined" msgstr "" -#: fortran/symbol.c:2040 +#: fortran/symbol.c:2029 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' at %C is a PRIVATE component of '%s'" msgstr "" -#: fortran/symbol.c:2058 +#: fortran/symbol.c:2047 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %C is not a member of the '%s' structure" msgstr "" -#: fortran/symbol.c:2196 +#: fortran/symbol.c:2186 #, gcc-internal-format, gfc-internal-format msgid "Duplicate statement label %d at %L and %L" msgstr "" -#: fortran/symbol.c:2207 +#: fortran/symbol.c:2197 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %C already referenced as branch target" msgstr "" -#: fortran/symbol.c:2217 +#: fortran/symbol.c:2207 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %C already referenced as a format label" msgstr "" -#: fortran/symbol.c:2223 +#: fortran/symbol.c:2213 #, gcc-internal-format, gfc-internal-format msgid "" "DO termination statement which is not END DO or CONTINUE with label %d at %C" msgstr "" -#: fortran/symbol.c:2265 +#: fortran/symbol.c:2255 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %C previously used as a FORMAT label" msgstr "" -#: fortran/symbol.c:2274 +#: fortran/symbol.c:2264 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %C previously used as branch target" msgstr "" -#: fortran/symbol.c:2280 +#: fortran/symbol.c:2270 #, gcc-internal-format, gfc-internal-format msgid "Shared DO termination label %d at %C" msgstr "" -#: fortran/symbol.c:2600 +#: fortran/symbol.c:2590 #, gcc-internal-format, gfc-internal-format msgid "Name '%s' at %C is an ambiguous reference to '%s' from module '%s'" msgstr "" -#: fortran/symbol.c:2603 +#: fortran/symbol.c:2593 #, gcc-internal-format, gfc-internal-format msgid "" "Name '%s' at %C is an ambiguous reference to '%s' from current program unit" msgstr "" #. Symbol is from another namespace. -#: fortran/symbol.c:2788 +#: fortran/symbol.c:2808 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %C has already been host associated" msgstr "" -#: fortran/symbol.c:3665 +#: fortran/symbol.c:3793 #, gcc-internal-format, gfc-internal-format msgid "" "Derived type '%s' declared at %L must have the BIND attribute to be C " "interoperable" msgstr "" -#: fortran/symbol.c:3683 +#: fortran/symbol.c:3811 #, gcc-internal-format, gfc-internal-format msgid "" "Derived type '%s' with BIND(C) attribute at %L is empty, and may be " "inaccessible by the C companion processor" msgstr "" -#: fortran/symbol.c:3704 +#: fortran/symbol.c:3832 #, gcc-internal-format, gfc-internal-format msgid "" "Component '%s' at %L cannot have the POINTER attribute because it is a " "member of the BIND(C) derived type '%s' at %L" msgstr "" -#: fortran/symbol.c:3714 +#: fortran/symbol.c:3842 #, gcc-internal-format, gfc-internal-format msgid "" "Procedure pointer component '%s' at %L cannot be a member of the BIND(C) " "derived type '%s' at %L" msgstr "" -#: fortran/symbol.c:3725 +#: fortran/symbol.c:3853 #, gcc-internal-format, gfc-internal-format msgid "" "Component '%s' at %L cannot have the ALLOCATABLE attribute because it is a " @@ -47041,7 +47089,7 @@ msgstr "" #. If the derived type is bind(c), all fields must be #. interop. -#: fortran/symbol.c:3764 +#: fortran/symbol.c:3892 #, gcc-internal-format, gfc-internal-format msgid "" "Component '%s' in derived type '%s' at %L may not be C interoperable, even " @@ -47051,26 +47099,26 @@ msgstr "" #. If derived type is param to bind(c) routine, or to one #. of the iso_c_binding procs, it must be interoperable, so #. all fields must interop too. -#: fortran/symbol.c:3773 +#: fortran/symbol.c:3901 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' in derived type '%s' at %L may not be C interoperable" msgstr "" -#: fortran/symbol.c:3787 +#: fortran/symbol.c:3915 #, gcc-internal-format, gfc-internal-format msgid "" "Derived type '%s' at %L cannot be declared with both PRIVATE and BIND(C) " "attributes" msgstr "" -#: fortran/symbol.c:3795 +#: fortran/symbol.c:3923 #, gcc-internal-format, gfc-internal-format msgid "" "Derived type '%s' at %L cannot have the SEQUENCE attribute because it is BIND" "(C)" msgstr "" -#: fortran/symbol.c:4688 fortran/symbol.c:4694 +#: fortran/symbol.c:4816 fortran/symbol.c:4822 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' is used before it is typed at %L" msgstr "" @@ -47196,59 +47244,59 @@ msgstr "" msgid "intrinsic variable which isn't a procedure" msgstr "" -#: fortran/trans-decl.c:3556 fortran/trans-decl.c:5433 +#: fortran/trans-decl.c:3556 fortran/trans-decl.c:5435 #, gcc-internal-format, gfc-internal-format msgid "Return value of function '%s' at %L not set" msgstr "" -#: fortran/trans-decl.c:3883 +#: fortran/trans-decl.c:3885 #, gcc-internal-format msgid "Deferred type parameter not yet supported" msgstr "" -#: fortran/trans-decl.c:4090 +#: fortran/trans-decl.c:4092 #, gcc-internal-format, gfc-internal-format msgid "backend decl for module variable %s already exists" msgstr "" -#: fortran/trans-decl.c:4614 +#: fortran/trans-decl.c:4616 #, gcc-internal-format, gfc-internal-format msgid "Dummy argument '%s' at %L was declared INTENT(OUT) but was not set" msgstr "" -#: fortran/trans-decl.c:4618 +#: fortran/trans-decl.c:4620 #, gcc-internal-format, gfc-internal-format msgid "" "Derived-type dummy argument '%s' at %L was declared INTENT(OUT) but was not " "set and does not have a default initializer" msgstr "" -#: fortran/trans-decl.c:4627 fortran/trans-decl.c:4742 +#: fortran/trans-decl.c:4629 fortran/trans-decl.c:4744 #, gcc-internal-format, gfc-internal-format msgid "Unused dummy argument '%s' at %L" msgstr "" -#: fortran/trans-decl.c:4641 +#: fortran/trans-decl.c:4643 #, gcc-internal-format, gfc-internal-format msgid "Unused module variable '%s' which has been explicitly imported at %L" msgstr "" -#: fortran/trans-decl.c:4649 +#: fortran/trans-decl.c:4651 #, gcc-internal-format, gfc-internal-format msgid "Unused variable '%s' declared at %L" msgstr "" -#: fortran/trans-decl.c:4697 +#: fortran/trans-decl.c:4699 #, gcc-internal-format, gfc-internal-format msgid "Unused parameter '%s' declared at %L" msgstr "" -#: fortran/trans-decl.c:4700 +#: fortran/trans-decl.c:4702 #, gcc-internal-format, gfc-internal-format msgid "Unused parameter '%s' which has been explicitly imported at %L" msgstr "" -#: fortran/trans-decl.c:4715 +#: fortran/trans-decl.c:4717 #, gcc-internal-format, gfc-internal-format msgid "Return value '%s' of function '%s' declared at %L not set" msgstr "" @@ -47284,12 +47332,12 @@ msgstr "" msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index" msgstr "" -#: fortran/trans-io.c:2032 +#: fortran/trans-io.c:2034 #, gcc-internal-format, gfc-internal-format msgid "Derived type '%s' at %L has PRIVATE components" msgstr "" -#: fortran/trans-io.c:2183 +#: fortran/trans-io.c:2185 #, gcc-internal-format, gfc-internal-format msgid "Bad IO basetype (%d)" msgstr "" 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/postreload.c b/gcc/postreload.c index daabaa1b703..33462e4dbad 100644 --- a/gcc/postreload.c +++ b/gcc/postreload.c @@ -1387,7 +1387,7 @@ reload_combine (void) } } - if (control_flow_insn && GET_CODE (PATTERN (insn)) != RETURN) + if (control_flow_insn && !ANY_RETURN_P (PATTERN (insn))) { /* Non-spill registers might be used at the call destination in some unknown fashion, so we have to mark the unknown use. */ @@ -1395,13 +1395,19 @@ reload_combine (void) if ((condjump_p (insn) || condjump_in_parallel_p (insn)) && JUMP_LABEL (insn)) - live = &LABEL_LIVE (JUMP_LABEL (insn)); + { + if (ANY_RETURN_P (JUMP_LABEL (insn))) + live = NULL; + else + live = &LABEL_LIVE (JUMP_LABEL (insn)); + } else live = &ever_live_at_start; - for (r = 0; r < FIRST_PSEUDO_REGISTER; r++) - if (TEST_HARD_REG_BIT (*live, r)) - reg_state[r].use_index = -1; + if (live) + for (r = 0; r < FIRST_PSEUDO_REGISTER; r++) + if (TEST_HARD_REG_BIT (*live, r)) + reg_state[r].use_index = -1; } reload_combine_note_use (&PATTERN (insn), insn, reload_combine_ruid, diff --git a/gcc/resource.c b/gcc/resource.c index 9de6f38a077..333c28f57e8 100644 --- a/gcc/resource.c +++ b/gcc/resource.c @@ -175,14 +175,12 @@ next_insn_no_annul (rtx insn) && NEXT_INSN (PREV_INSN (insn)) != insn) { rtx next = NEXT_INSN (insn); - enum rtx_code code = GET_CODE (next); - while ((code == INSN || code == JUMP_INSN || code == CALL_INSN) + while ((NONJUMP_INSN_P (next) || JUMP_P (next) || CALL_P (next)) && INSN_FROM_TARGET_P (next)) { insn = next; next = NEXT_INSN (insn); - code = GET_CODE (next); } } diff --git a/gcc/rtl.c b/gcc/rtl.c index bc49fc86fe9..b2d88f783b7 100644 --- a/gcc/rtl.c +++ b/gcc/rtl.c @@ -256,7 +256,11 @@ copy_rtx (rtx orig) /* SCRATCH must be shared because they represent distinct values. */ return orig; case CLOBBER: - if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER) + /* Share clobbers of hard registers (like cc0), but do not share pseudo reg + clobbers or clobbers of hard registers that originated as pseudos. + This is needed to allow safe register renaming. */ + if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER + && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0))) return orig; break; diff --git a/gcc/rtl.h b/gcc/rtl.h index 93a64f4d832..b9defcceba4 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -960,9 +960,8 @@ extern const char * const reg_note_name[]; #define NOTE_KIND(INSN) XCINT (INSN, 5, NOTE) /* Nonzero if INSN is a note marking the beginning of a basic block. */ -#define NOTE_INSN_BASIC_BLOCK_P(INSN) \ - (GET_CODE (INSN) == NOTE \ - && NOTE_KIND (INSN) == NOTE_INSN_BASIC_BLOCK) +#define NOTE_INSN_BASIC_BLOCK_P(INSN) \ + (NOTE_P (INSN) && NOTE_KIND (INSN) == NOTE_INSN_BASIC_BLOCK) /* Variable declaration and the location of a variable. */ #define PAT_VAR_LOCATION_DECL(PAT) (XCTREE ((PAT), 0, VAR_LOCATION)) @@ -1063,7 +1062,7 @@ enum label_kind /* Retrieve the kind of LABEL. */ #define LABEL_KIND(LABEL) __extension__ \ ({ __typeof (LABEL) const _label = (LABEL); \ - if (GET_CODE (_label) != CODE_LABEL) \ + if (! LABEL_P (_label)) \ rtl_check_failed_flag ("LABEL_KIND", _label, __FILE__, __LINE__, \ __FUNCTION__); \ (enum label_kind) ((_label->jump << 1) | _label->call); }) @@ -1072,7 +1071,7 @@ enum label_kind #define SET_LABEL_KIND(LABEL, KIND) do { \ __typeof (LABEL) const _label = (LABEL); \ const unsigned int _kind = (KIND); \ - if (GET_CODE (_label) != CODE_LABEL) \ + if (! LABEL_P (_label)) \ rtl_check_failed_flag ("SET_LABEL_KIND", _label, __FILE__, __LINE__, \ __FUNCTION__); \ _label->jump = ((_kind >> 1) & 1); \ diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c index 43700cff151..c320bcf5807 100644 --- a/gcc/simplify-rtx.c +++ b/gcc/simplify-rtx.c @@ -3623,10 +3623,13 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, return gen_rtx_CONST_VECTOR (mode, v); } - /* Try to merge VEC_SELECTs from the same vector into a single one. */ + /* Try to merge two VEC_SELECTs from the same vector into a single one. + Restrict the transformation to avoid generating a VEC_SELECT with a + mode unrelated to its operand. */ if (GET_CODE (trueop0) == VEC_SELECT && GET_CODE (trueop1) == VEC_SELECT - && rtx_equal_p (XEXP (trueop0, 0), XEXP (trueop1, 0))) + && rtx_equal_p (XEXP (trueop0, 0), XEXP (trueop1, 0)) + && GET_MODE (XEXP (trueop0, 0)) == mode) { rtx par0 = XEXP (trueop0, 1); rtx par1 = XEXP (trueop1, 1); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 7d918f826de..7e1cd5b0d8f 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,260 @@ +2013-03-25 Kyrylo Tkachov <kyrylo.tkachov@arm.com> + PR target/56720 + * gcc.target/arm/neon-vcond-gt.c: New test. + * gcc.target/arm/neon-vcond-ltgt.c: Likewise. + * gcc.target/arm/neon-vcond-unordered.c: Likewise. + +2013-03-25 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56689 + * gcc.dg/torture/pr56689.c: New testcase. + +2013-03-25 Kai Tietz <ktietz@redhat.com> + + * g++.dg/torture/20121105-1.C: Adjust for LLP64 targets. + +2013-03-24 Tobias Burnus <burnus@net-b.de> + + PR fortran/56696 + * gfortran.dg/eof_5.f90: New. + +2013-03-23 Sebastian Huber <sebastian.huber@embedded-brains.de> + + * gcc.c-torture/execute/builtins/builtins.exp: Sort targets + alphabetically. + +2013-03-22 Uros Bizjak <ubizjak@gmail.com> + + * gcc.target/i386/pr22152.c (dg-options): Add -mtune=core2. + +2013-03-22 Sebastian Huber <sebastian.huber@embedded-brains.de> + + PR testsuite/55994 + * gcc.c-torture/execute/builtins/builtins.exp: Add + -Wl,--allow-multiple-definition for RTEMS targets. + +2013-03-22 Ian Bolton <ian.bolton@arm.com> + + * gcc.target/aarch64/movk.c: New test. + +2013-03-21 Marc Glisse <marc.glisse@inria.fr> + + * g++.dg/ext/vector21.C: New testcase. + +2013-03-21 Christophe Lyon <christophe.lyon@linaro.org> + + * gcc.target/arm/neon-for-64bits-1.c: New tests. + * gcc.target/arm/neon-for-64bits-2.c: Likewise. + +2013-03-21 Richard Biener <rguenther@suse.de> + + * gcc.dg/vect/vect-outer-3a-big-array.c: Adjust. + * gcc.dg/vect/vect-outer-3a.c: Likewise. + +2013-03-21 Naveen H.S <Naveen.Hurugalawadi@caviumnetworks.com> + + * gcc.target/aarch64/vect.c: Test and result vector added + for sabd and saba instructions. + * gcc.target/aarch64/vect-compile.c: Check for sabd and saba + instructions in assembly. + * gcc.target/aarch64/vect.x: Add sabd and saba test functions. + * gcc.target/aarch64/vect-fp.c: Test and result vector added + for fabd instruction. + * gcc.target/aarch64/vect-fp-compile.c: Check for fabd + instruction in assembly. + * gcc.target/aarch64/vect-fp.x: Add fabd test function. + +2013-03-20 Jeff Law <law@redhat.com> + + * g++.dg/tree-ssa/ssa-dom.C: New test. + +2013-03-20 Michael Meissner <meissner@linux.vnet.ibm.com> + + * gcc.target/powerpc/mmfpgpr.c: New test. + * gcc.target/powerpc/sd-vsx.c: Likewise. + * gcc.target/powerpc/sd-pwr6.c: Likewise. + * gcc.target/powerpc/vsx-float0.c: Likewise. + +2013-03-20 Marc Glisse <marc.glisse@inria.fr> + + PR tree-optimization/56355 + * gcc.dg/pr56355-1.c: New file. + +2013-03-20 Catherine Moore <clm@codesourcery.com> + Richard Sandiford <rdsandiford@googlemail.com> + + * gcc.target/mips/mips.exp: Add microMIPS support. + * gcc.target/mips/umips-movep-2.c: New test. + * gcc.target/mips/umips-lwp-2.c: New test. + * gcc.target/mips/umips-swp-5.c: New test. + * gcc.target/mips/umips-constraints-1.c: New test. + * gcc.target/mips/umips-lwp-3.c: New test. + * gcc.target/mips/umips-swp-6.c: New test. + * gcc.target/mips/umips-constraints-2.c: New test. + * gcc.target/mips/umips-save-restore-1.c: New test. + * gcc.target/mips/umips-lwp-4.c: New test. + * gcc.target/mips/umips-swp-7.c: New test. + * gcc.target/mips/umips-save-restore-2.c: New test. + * gcc.target/mips/umips-lwp-swp-volatile.c: New test. + * gcc.target/mips/umips-lwp-5.c: New test. + * gcc.target/mips/umips-save-restore-3.c: New test. + * gcc.target/mips/umips-lwp-6.c: New test. + * gcc.target/mips/umips-swp-1.c: New test. + * gcc.target/mips/umips-lwp-7.c: New test. + * gcc.target/mips/umips-swp-2.c: New test. + * gcc.target/mips/umips-lwp-8.c: New test. + * gcc.target/mips/umips-swp-3.c: New test. + * gcc.target/mips/umips-movep-1.c: New test. + * gcc.target/mips/umips-lwp-1.c: New test. + * gcc.target/mips/umips-swp-4.c: New test. + +2013-03-20 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56661 + * gcc.dg/torture/pr56661.c: New testcase. + +2013-03-20 Bill Schmidt <wschmidt@linux.vnet.ibm.com> + + PR rtl-optimization/56605 + * gcc.target/powerpc/pr56605.c: New. + +2013-03-20 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> + + PR fortran/54932 + * gfortran.dg/do_1.f90: Don't xfail. + +2013-03-20 Tilo Schwarz <tilo@tilo-schwarz.de> + + PR libfortran/51825 + * gfortran.dg/namelist_77.f90: New. + * gfortran.dg/namelist_78.f90: New. + +2013-03-20 Tilo Schwarz <tilo@tilo-schwarz.de> + + PR libfortran/48618 + * gfortran.dg/open_negative_unit_1.f90: New. + +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. + +2013-03-15 Kai Tietz <ktietz@redhat.com> + + * gcc.target/i386/movti.c: Don't test for x64 mingw. + * gcc.target/i386/pr20020-1.c: Likewise. + * gcc.target/i386/pr20020-2.c: Likewise. + * gcc.target/i386/pr20020-3.c: Likewise. + * gcc.target/i386/pr53425-1.c: Likewise. + * gcc.target/i386/pr53425-2.c: Likewise. + * gcc.target/i386/pr55093.c: Likewise. + * gcc.target/i386/pr53907.c: Adjust test for LLP64 targets. + +2013-03-15 Jakub Jelinek <jakub@redhat.com> + + PR debug/56307 + * gcc.dg/tree-ssa/pr55579.c: Add -fvar-tracking-assignments to + dg-options. Remove 32-bit hppa*-*-hpux* xfail. + +2013-03-14 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/53265 + * gcc.dg/graphite/scop-3.c (toto): Increase array size to avoid + undefined behavior. + * gcc.dg/graphite/id-6.c (test): Likewise. + * gcc.dg/graphite/pr35356-2.c: Adjust regexp patterns to only look for + MIN_EXPR and MAX_EXPR in GIMPLE stmts. + + PR tree-optimization/53265 + * gcc.dg/pr53265.c: New test. + * gcc.dg/torture/pr49518.c: Add -Wno-aggressive-loop-optimizations + to dg-options. + * g++.dg/opt/longbranch2.C (EBCOTLut): Double sizes of a2 and a3 + arrays. + * gcc.dg/tree-ssa/cunroll-10.c (main): Rename to foo. Add argument + n, use it as high bound instead of 4. + +2013-03-13 Oleg Endo <olegendo@gcc.gnu.org> + + PR target/49880 + * gcc.target/sh/pr49880-1.c: New. + * gcc.target/sh/pr49880-2.c: New. + * gcc.target/sh/pr49880-3.c: New. + * gcc.target/sh/pr49880-4.c: New. + * gcc.target/sh/pr49880-5.c: New. + +2013-03-13 Paolo Carlini <paolo.carlini@oracle.com> + + * g++.dg/cpp0x/alias-decl-32.C: Remove redundant bits. + +2013-03-13 Richard Biener <rguenther@suse.de> + + PR tree-optimization/56608 + * gcc.dg/vect/fast-math-bb-slp-call-3.c: New testcase. + +2013-03-13 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/56611 + * g++.dg/cpp0x/alias-decl-32.C: New. + +2013-03-11 Jan Hubicka <jh@suse.cz> + + PR middle-end/56571 + * gcc.c-torture/compile/pr56571.c: New testcase. + +2013-03-11 John David Anglin <dave.anglin@nrc-cnrc.gc.ca> + + * gcc.dg/tree-ssa/vector-4.c: Add comment regarding xfail. + * gcc.dg/tree-ssa/pr55579.c: Likewise. + 2013-03-11 Dominique d'Humieres <dominiq@lps.ens.fr> * gcc.dg/inline_3.c: Remove target and dg-excess-errors. @@ -370,7 +627,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> @@ -474,7 +731,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> @@ -557,9 +814,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/alias-decl-32.C b/gcc/testsuite/g++.dg/cpp0x/alias-decl-32.C new file mode 100644 index 00000000000..cb39edde8f6 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/alias-decl-32.C @@ -0,0 +1,20 @@ +// PR c++/56611 +// { dg-do compile { target c++11 } } + +template<class T> struct remove_reference { typedef T type; }; +template<class T> struct remove_reference<T&> { typedef T type; }; +template<class T> T declval() { return T(); } + +int f(int, int){return 0;} +struct Func{}; + +template<class... Args> using result2 += decltype(f(declval<typename remove_reference<Args>::type>()...)); + +template<class Sig> struct R; +template<class This, class... Args> struct R< This(Args...) > +{ + typedef result2<Args...> type; +}; + +typedef R< Func(int, int) >::type R_type; 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-static11.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-static11.C new file mode 100644 index 00000000000..91cc25a71c3 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-static11.C @@ -0,0 +1,14 @@ +// PR c++/54532 +// { dg-do compile { target c++11 } } + +#define SA(X) static_assert(X,#X) + +struct A { + int i; + constexpr static int A::*p = &A::i; +}; + +constexpr A a = { 42 }; +SA(a.*A::p == 42); + +constexpr int A::* A::p; 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/initlist-defarg1.C b/gcc/testsuite/g++.dg/cpp0x/initlist-defarg1.C new file mode 100644 index 00000000000..45eb2d5e1f0 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/initlist-defarg1.C @@ -0,0 +1,36 @@ +// PR c++/56614 +// { dg-require-effective-target c++11 } + +#include <initializer_list> + +namespace std +{ + template<typename T> + struct allocator + { }; + + template<typename T, typename Alloc = std::allocator<T> > + struct vector + { + vector(std::initializer_list<T>, const Alloc& = Alloc()) { } + }; +} + +void func() { } + +enum E { ee }; + +struct C +{ + template<typename T> + C(T, std::vector<E> = std::vector<E>({ ee })) + { } +}; + +struct G +{ + void gen() + { + C c(&func); + } +}; 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/cpp0x/trailing9.C b/gcc/testsuite/g++.dg/cpp0x/trailing9.C new file mode 100644 index 00000000000..d7895b38e3e --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/trailing9.C @@ -0,0 +1,12 @@ +// PR c++/56646 +// { dg-require-effective-target c++11 } + +struct A { + void f(); +}; + +void A::f() { + struct B { + auto g() -> void { } + }; +} 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/eh/anon1.C b/gcc/testsuite/g++.dg/eh/anon1.C new file mode 100644 index 00000000000..2a5ef4bc5e3 --- /dev/null +++ b/gcc/testsuite/g++.dg/eh/anon1.C @@ -0,0 +1,26 @@ +// Test that the anonymous namespace isn't mangled with random characters, +// but also doesn't get mixed up with an anonymous namespace in another +// translation unit. + +// { dg-do run } +// { dg-additional-sources "anon1a.cc" } + +namespace { + struct A + { + virtual void f(); + }; + + void A::f() { } +} + +extern void g(); + +int main() +{ + try { + try { + g(); + } catch (A) { __builtin_abort(); } + } catch (...) { } +} diff --git a/gcc/testsuite/g++.dg/eh/anon1a.cc b/gcc/testsuite/g++.dg/eh/anon1a.cc new file mode 100644 index 00000000000..ba161ac2b01 --- /dev/null +++ b/gcc/testsuite/g++.dg/eh/anon1a.cc @@ -0,0 +1,10 @@ +namespace { + struct A + { + virtual void f(); + }; + + void A::f() { } +} + +void g() { throw A(); } diff --git a/gcc/testsuite/g++.dg/eh/anon2.C b/gcc/testsuite/g++.dg/eh/anon2.C new file mode 100644 index 00000000000..9ff9ee3ab7f --- /dev/null +++ b/gcc/testsuite/g++.dg/eh/anon2.C @@ -0,0 +1,24 @@ +// Test that the anonymous namespace isn't mangled with random characters, +// but also doesn't get mixed up with an anonymous namespace in another +// translation unit. +// { dg-final { scan-assembler "\\*N12_GLOBAL__N_11AE" } } + +namespace { + struct A + { + virtual void f(); + }; + + void A::f() { } +} + +extern void g(); + +int main() +{ + try { + try { + g(); + } catch (A) { __builtin_abort(); } + } catch (...) { } +} diff --git a/gcc/testsuite/g++.dg/ext/vector21.C b/gcc/testsuite/g++.dg/ext/vector21.C new file mode 100644 index 00000000000..71634c32786 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/vector21.C @@ -0,0 +1,39 @@ +/* { dg-do compile } */ +/* { dg-options "-O -fdump-tree-gimple" } */ + +typedef int vec __attribute__ ((vector_size (4 * sizeof (int)))); + +void f1 (vec *x) +{ + *x = (*x >= 0) ? *x : -*x; +} +void f2 (vec *x) +{ + *x = (0 < *x) ? *x : -*x; +} +void g1 (vec *x) +{ + *x = (*x < 0) ? -*x : *x; +} +void g2 (vec *x) +{ + *x = (0 > *x) ? -*x : *x; +} +void h (vec *x, vec *y) +{ + *x = (*x < *y) ? *y : *x; +} +void i (vec *x, vec *y) +{ + *x = (*x < *y) ? *x : *y; +} +void j (vec *x, vec *y) +{ + *x = (*x < *y) ? *x : *x; +} + +/* { dg-final { scan-tree-dump-times "ABS_EXPR" 4 "gimple" } } */ +/* { dg-final { scan-tree-dump "MIN_EXPR" "gimple" } } */ +/* { dg-final { scan-tree-dump "MAX_EXPR" "gimple" } } */ +/* { dg-final { scan-tree-dump-not "VEC_COND_EXPR" "gimple" } } */ +/* { dg-final { cleanup-tree-dump "gimple" } } */ 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/opt/longbranch2.C b/gcc/testsuite/g++.dg/opt/longbranch2.C index de63f697fcf..4a8d5eef735 100644 --- a/gcc/testsuite/g++.dg/opt/longbranch2.C +++ b/gcc/testsuite/g++.dg/opt/longbranch2.C @@ -15,8 +15,8 @@ public: class EBCOTLut : public JKeeper { unsigned char a1[1<<8]; - unsigned char a2[1<<8]; - unsigned char a3[1<<8]; + unsigned char a2[1<<9]; + unsigned char a3[1<<9]; long a4[1<<9]; public: EBCOTLut(void); 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..6905262d6cb --- /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" "" } + +int main() { + g<A<int> >(0); // { dg-error "no matching function" } +} 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/const6.C b/gcc/testsuite/g++.dg/template/const6.C new file mode 100644 index 00000000000..3c40d2635bc --- /dev/null +++ b/gcc/testsuite/g++.dg/template/const6.C @@ -0,0 +1,7 @@ +// PR c++/56684 + +template < int T > struct S +{ + static const int Ti = T; + S() { 1 << Ti; } +}; diff --git a/gcc/testsuite/g++.dg/template/friend54.C b/gcc/testsuite/g++.dg/template/friend54.C new file mode 100644 index 00000000000..ead7a72fcc9 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/friend54.C @@ -0,0 +1,18 @@ +// PR c++/56642 + +template <class T> struct A; + +template <class T> +A<T> f(T*) { return A<T>(); } + +template <class T> +struct A +{ + friend A f<T>(T*); +}; + +int main() +{ + int *p = 0; + f(p); +} 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/20121105-1.C b/gcc/testsuite/g++.dg/torture/20121105-1.C index 03323421a5e..10eeeb90945 100644 --- a/gcc/testsuite/g++.dg/torture/20121105-1.C +++ b/gcc/testsuite/g++.dg/torture/20121105-1.C @@ -2,6 +2,8 @@ // Reported by Remi Vanicat <vanicat@debian.org> // Reduced testcase by Markus Trippelsdorf <markus@trippelsdorf.de> +__extension__ typedef __INTPTR_TYPE__ intptr_t; + struct A; struct B { @@ -25,7 +27,7 @@ struct D }; D c(0); -const long d = (long)&c; +const intptr_t d = (intptr_t)&c; B *const e = (B *)&d; static bool 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/tree-ssa/ssa-dom.C b/gcc/testsuite/g++.dg/tree-ssa/ssa-dom.C new file mode 100644 index 00000000000..5f63865c166 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/ssa-dom.C @@ -0,0 +1,104 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-dom1" } */ + +typedef long unsigned int size_t; +extern void abort (void) __attribute__ ((__noreturn__)); +union tree_node; +typedef union tree_node *tree; +union gimple_statement_d; +typedef union gimple_statement_d *gimple; +typedef const union gimple_statement_d *const_gimple; + +enum gimple_code +{ + GIMPLE_RETURN = 10, +}; + + + + + +struct gimple_statement_base +{ + + + enum gimple_code code:8; +}; + + +enum gimple_statement_structure_enum +{ + xyz +}; + + + + + + +union gimple_statement_d +{ + struct gimple_statement_base gsbase; +}; + + + + + +extern size_t const gimple_ops_offset_[]; + + +extern enum gimple_statement_structure_enum const gss_for_code_[]; + + +static inline enum gimple_code +gimple_code (const_gimple g) +{ + return g->gsbase.code; +} + + + + +static inline enum gimple_statement_structure_enum +gss_for_code (enum gimple_code code) +{ + return gss_for_code_[code]; +} + + + + +static inline enum gimple_statement_structure_enum +gimple_statement_structure (gimple gs) +{ + return gss_for_code (gimple_code (gs)); +} + + +static inline tree * +gimple_ops (gimple gs) +{ + size_t off; + off = gimple_ops_offset_[gimple_statement_structure (gs)]; + return (tree *) ((char *) gs + off); +} + + +static inline void +gimple_set_op (gimple gs, unsigned i, tree op) +{ + gimple_ops (gs)[i] = op; +} + +void +gimple_return_set_retval (gimple gs, tree retval) +{ + const_gimple __gs = (gs); + if (gimple_code (__gs) != (GIMPLE_RETURN)) + abort (); + gimple_set_op (gs, 0, retval); +} +/* { dg-final { scan-tree-dump-times "gss_for_code_.10." 1 "dom1"} } */ +/* { dg-final { cleanup-tree-dump "dom1" } } */ + 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.c-torture/compile/pr56571.c b/gcc/testsuite/gcc.c-torture/compile/pr56571.c new file mode 100644 index 00000000000..248148c9ff8 --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/pr56571.c @@ -0,0 +1,8 @@ +/* { dg-options "-funroll-loops -ftracer" } */ +int a, b; + +int f(void) +{ + (a % b) && f(); + a = (0 || a | (a ? : 1)); +} diff --git a/gcc/testsuite/gcc.c-torture/execute/builtins/builtins.exp b/gcc/testsuite/gcc.c-torture/execute/builtins/builtins.exp index 45cfaddba19..d157fe392f5 100644 --- a/gcc/testsuite/gcc.c-torture/execute/builtins/builtins.exp +++ b/gcc/testsuite/gcc.c-torture/execute/builtins/builtins.exp @@ -43,7 +43,8 @@ if [istarget "powerpc-*-darwin*"] { } if { [istarget *-*-eabi*] || [istarget *-*-elf] - || [istarget *-*-mingw*] } { + || [istarget *-*-mingw*] + || [istarget *-*-rtems*] } { lappend additional_flags "-Wl,--allow-multiple-definition" } diff --git a/gcc/testsuite/gcc.dg/graphite/id-6.c b/gcc/testsuite/gcc.dg/graphite/id-6.c index c3aab432a59..dd6fecda3bd 100644 --- a/gcc/testsuite/gcc.dg/graphite/id-6.c +++ b/gcc/testsuite/gcc.dg/graphite/id-6.c @@ -2,7 +2,7 @@ void foo (int); int test () { - int a[N]; + int a[N + 8]; unsigned i; for (i = 0; i < N; i++) diff --git a/gcc/testsuite/gcc.dg/graphite/pr35356-2.c b/gcc/testsuite/gcc.dg/graphite/pr35356-2.c index 66cfdea5aef..b406d1096ba 100644 --- a/gcc/testsuite/gcc.dg/graphite/pr35356-2.c +++ b/gcc/testsuite/gcc.dg/graphite/pr35356-2.c @@ -39,6 +39,6 @@ foo (int bar, int n, int k) */ -/* { dg-final { scan-tree-dump-times "MIN_EXPR" 4 "graphite" } } */ -/* { dg-final { scan-tree-dump-times "MAX_EXPR" 4 "graphite" } } */ +/* { dg-final { scan-tree-dump-times "MIN_EXPR\[^\\n\\r]*;" 4 "graphite" } } */ +/* { dg-final { scan-tree-dump-times "MAX_EXPR\[^\\n\\r]*;" 4 "graphite" } } */ /* { dg-final { cleanup-tree-dump "graphite" } } */ diff --git a/gcc/testsuite/gcc.dg/graphite/scop-3.c b/gcc/testsuite/gcc.dg/graphite/scop-3.c index e20bfdcb34b..18917c0edcc 100644 --- a/gcc/testsuite/gcc.dg/graphite/scop-3.c +++ b/gcc/testsuite/gcc.dg/graphite/scop-3.c @@ -1,7 +1,7 @@ int toto() { int i, j, k; - int a[100][100]; + int a[100][200]; int b[100]; for (i = 1; i < 100; i++) diff --git a/gcc/testsuite/gcc.dg/pr53265.c b/gcc/testsuite/gcc.dg/pr53265.c new file mode 100644 index 00000000000..c60a736a927 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr53265.c @@ -0,0 +1,156 @@ +/* PR tree-optimization/53265 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -Wall" } */ + +void bar (void *); +int baz (int); + +void +fn1 (void) +{ + unsigned int a[128]; + int i; + + for (i = 0; i < 128; ++i) /* { dg-message "note: containing loop" } */ + a[i] = i * 0x02000001; /* { dg-warning "invokes undefined behavior" } */ + bar (a); +} + +void +fn2 (void) +{ + unsigned long long a[128]; + int i; + + for (i = 0; i < 128; i++) /* { dg-message "note: containing loop" } */ + a[i] = (i + 1LL) * 0x0123456789ABCDEFLL; /* { dg-warning "invokes undefined behavior" } */ + bar (a); +} + +void +fn3 (void) +{ + unsigned char a[16], b[16], c[16]; + int i; + + bar (b); + for (i = 0; i < (int) (sizeof (a) / sizeof (a[0])); i++) /* { dg-message "note: containing loop" } */ + { + c[i + 8] = b[i]; /* { dg-warning "invokes undefined behavior" } */ + a[i + 8] = b[i + 8]; + } + bar (a); + bar (c); +} + +void +fn4 (void) +{ + unsigned int *a[32], *o, i; + + bar (a); + for (i = 0; i <= sizeof (a) / sizeof (a[0]); i++) /* { dg-message "note: containing loop" "" { xfail *-*-* } } */ + { + o = a[i]; /* { dg-warning "invokes undefined behavior" "" { xfail *-*-* } } */ + bar (o); + } +} + +void +fn5 (void) +{ + unsigned short a[23940]; + unsigned int b[1140]; + int j; + + bar (b); + for (j = 0; j < 1140; j++) /* { dg-message "note: containing loop" } */ + a[23940 + j - 950] = b[j]; /* { dg-warning "invokes undefined behavior" } */ + bar (a); +} + +void +fn6 (void) +{ + double a[4][3], b[12]; + int i; + bar (b); + for (i = 0; i < 12; i++) /* { dg-message "note: containing loop" } */ + a[0][i] = b[i] / 10000.0; /* { dg-warning "invokes undefined behavior" } */ + bar (a); +} + +void +fn7 (void) +{ + int a[16], b, c; + bar (a); + for (b = a[c = 0]; c < 16; b = a[++c]) /* { dg-warning "invokes undefined behavior" "" { xfail *-*-* } } */ + baz (b); +} + +/* { dg-message "note: containing loop" "" { xfail *-*-* } 88 } */ + +const void *va, *vb, *vc, *vd, *ve; +const void *vf[4]; +void +fn8 (void) +{ + unsigned long i; + vf[0] = va; vf[1] = vb; vf[2] = vc; vf[3] = vd; + for (i = 0; i < (sizeof (vf) / sizeof (vf[0])); i++) + if (!vf[i]) + vf[i] = ve; +} + +int wa, wb[53][5], wc[53][5]; + +void +fn9 (void) +{ + int i, j, k; + for (i = 0; i < 53; i++) + for (j = 16 / (((wa & 1) != 0) ? 8 : 4); j > 0; j--) + { + int d = 1; + if (wb[i][j] == 0 || wc[i][1] != 0) + continue; + for (k = 0; k < j; k++) + if (wc[i + k][1]) + { + d = 0; + break; + } + if (!d) + continue; + wc[i][j] = baz (0); + } +} + +int xa[18]; + +void +fn10 (void) +{ + int i; + for (i = 16; i < 32; i++) /* { dg-message "note: containing loop" } */ + xa[i] = 26; /* { dg-warning "invokes undefined behavior" } */ +} + +__attribute__((noinline)) static void +fn11 (int x) +{ + int i = 1; + if (x > 1) + do + baz (i); + while (++i != x); /* { dg-bogus "invokes undefined behavior" } */ +} + +void +fn12 (void) +{ + fn11 (1); + fn11 (1); + fn11 (1); +} diff --git a/gcc/testsuite/gcc.dg/pr56355-1.c b/gcc/testsuite/gcc.dg/pr56355-1.c new file mode 100644 index 00000000000..08b9c2e7109 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr56355-1.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -Wstrict-overflow=4" } */ + +int +f (int i) +{ + return __builtin_abs (i * i); /* { dg-warning "assuming signed overflow" } */ +} diff --git a/gcc/testsuite/gcc.dg/torture/pr49518.c b/gcc/testsuite/gcc.dg/torture/pr49518.c index 84a10fbbeeb..55761fd6108 100644 --- a/gcc/testsuite/gcc.dg/torture/pr49518.c +++ b/gcc/testsuite/gcc.dg/torture/pr49518.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-options "-Wno-aggressive-loop-optimizations" } */ int a, b; struct S { unsigned int s, t, u; } c, d = { 0, 1, 0 }; diff --git a/gcc/testsuite/gcc.dg/torture/pr56661.c b/gcc/testsuite/gcc.dg/torture/pr56661.c new file mode 100644 index 00000000000..6fdaedb3176 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr56661.c @@ -0,0 +1,46 @@ +/* { dg-do run } */ + +__attribute__((noinline, noclone)) void +bar (int *b) +{ + b[0] = b[1] = b[2] = 1; +} + +__attribute__((noinline, noclone)) int +baz (int x) +{ + if (x != 1) + __builtin_abort (); +} + +void +foo (int x) +{ + if (x == 0) + { + int *b = __builtin_malloc (3 * sizeof (int)); + while (b[0]) + ; + } + else if (x == 1) + { + int i, j; + int *b = __builtin_malloc (3 * sizeof (int)); + for (i = 0; i < 2; i++) + { + bar (b); + for (j = 0; j < 3; ++j) + baz (b[j]); + baz (b[0]); + } + } +} + +int +main () +{ + int x = 1; + asm volatile ("" : "+r" (x)); + foo (x); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr56689.c b/gcc/testsuite/gcc.dg/torture/pr56689.c new file mode 100644 index 00000000000..719f528c2c0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr56689.c @@ -0,0 +1,46 @@ +/* { dg-do compile } */ + +extern int baz (); +extern void bar (void); +extern void noret (void) __attribute__ ((__noreturn__)); + +void +fix_register (const char *name, int fixed, int call_used, int nregs) +{ + int i; + int reg; + + if ((reg = baz ()) >= 0) + { + for (i = reg; i < nregs; i++) + { + if ((i == 15 || i == 11) && (fixed == 0 || call_used == 0)) + { + switch (fixed) + { + case 0: + switch (call_used) + { + case 1: + bar (); + break; + default: + (noret ()); + } + case 1: + switch (call_used) + { + case 1: + break; + case 0: + default: + (noret ()); + } + break; + default: + (noret ()); + } + } + } + } +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/cunroll-10.c b/gcc/testsuite/gcc.dg/tree-ssa/cunroll-10.c index 7893565918a..f2cd904efc6 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/cunroll-10.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/cunroll-10.c @@ -2,10 +2,11 @@ /* { dg-options "-O3 -Warray-bounds -fdump-tree-cunroll-details" } */ int a[3]; int b[4]; -main() +int +foo (int n) { int i; - for (i=0;i<4;i++) + for (i=0;i<n;i++) if (b[i]==2) a[i]++; } diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr55579.c b/gcc/testsuite/gcc.dg/tree-ssa/pr55579.c index 741bd41551d..16807cf66c6 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr55579.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr55579.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -g -fdump-tree-esra" } */ +/* { dg-options "-O2 -g -fdump-tree-esra -fvar-tracking-assignments" } */ struct S { int a; char b; char c; short d; }; @@ -11,5 +11,5 @@ foo (int x) return x; } -/* { dg-final { scan-tree-dump "Created a debug-only replacement for s" "esra" {xfail { hppa*-*-hpux* && { ! lp64 } } } } } */ +/* { dg-final { scan-tree-dump "Created a debug-only replacement for s" "esra" } } */ /* { dg-final { cleanup-tree-dump "esra" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vector-4.c b/gcc/testsuite/gcc.dg/tree-ssa/vector-4.c index c2a39ca6751..10aebc47b45 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/vector-4.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/vector-4.c @@ -9,6 +9,7 @@ v4si vs (v4si a, v4si b) } /* The compound literal should be placed directly in the vec_perm. */ +/* Test is xfailed on 32-bit hppa*-*-* because target-callee-copies. */ /* { dg-final { scan-tree-dump-times "VEC_PERM_EXPR <a, b, { 0, 4, 1, 5 }>;" 1 "gimple" { xfail { hppa*-*-* && { ! lp64 } } } } } */ /* { dg-final { cleanup-tree-dump "gimple" } } */ 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/testsuite/gcc.dg/vect/fast-math-bb-slp-call-3.c b/gcc/testsuite/gcc.dg/vect/fast-math-bb-slp-call-3.c new file mode 100644 index 00000000000..5878d418f50 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/fast-math-bb-slp-call-3.c @@ -0,0 +1,68 @@ +#include <stdlib.h> +#include <math.h> + +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) +#define MAX(a, b) (((a) > (b)) ? (a) : (b)) + +typedef struct { + int initialHeight, initialWidth; + int rotatedHeight, rotatedWidth; + int autoCropHeight, autoCropWidth; +} ufraw_data; + +void __attribute__((noinline,noclone)) +ufraw_test(ufraw_data *uf) +{ + int iWidth = uf->initialWidth; + int iHeight = uf->initialHeight; + double aspectRatio = ((double)iWidth) / iHeight; + double midX = iWidth / 2.0 - 0.5; + double midY = iHeight / 2.0 - 0.5; + double maxX = 0, maxY = 0; + double minX = 999999, minY = 999999; + double lastX = 0, lastY = 0, area = 0; + double scale; + int i; + for (i = 0; i < iWidth + iHeight - 1; i++) + { + int x, y; + if (i < iWidth) { // Trace the left border of the image + x = i; + y = 0; + } else { // Trace the bottom border of the image + x = iWidth - 1; + y = i - iWidth + 1; + } + double srcX = x - midX; + double srcY = y - midY; + // A digital planimeter: + area += srcY * lastX - srcX * lastY; + lastX = srcX; + lastY = srcY; + maxX = MAX(maxX, fabs(srcX)); + maxY = MAX(maxY, fabs(srcY)); + if (fabs(srcX / srcY) > aspectRatio) + minX = MIN(minX, fabs(srcX)); + else + minY = MIN(minY, fabs(srcY)); + } + scale = sqrt((iWidth - 1) * (iHeight - 1) / area); + uf->rotatedWidth = MIN(ceil(2 * maxX + 1.0) * scale, 2 * iWidth); + uf->rotatedHeight = MIN(ceil(2 * maxY + 1.0) * scale, 2 * iHeight); + uf->autoCropWidth = MIN(floor(2 * minX) * scale, 2 * iWidth); + uf->autoCropHeight = MIN(floor(2 * minY) * scale, 2 * iHeight); + if (uf->autoCropWidth != 3) + abort (); +} + +int main() +{ + ufraw_data uf_data; + ufraw_data *uf = &uf_data; + uf->initialWidth = 4; + uf->initialHeight = 5; + ufraw_test(uf); + return 0; +} + +/* { dg-final { cleanup-tree-dump "slp" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-3a-big-array.c b/gcc/testsuite/gcc.dg/vect/vect-outer-3a-big-array.c index c6486db691b..ecb2d9076d2 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-3a-big-array.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-3a-big-array.c @@ -49,6 +49,5 @@ int main (void) } /* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail vect_no_align } } } */ -/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 2 "vect" { target { ! vect_multiple_sizes } } } } */ -/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 3 "vect" { target vect_multiple_sizes } } } */ +/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 1 "vect" } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c b/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c index 3d6e1076e79..d0b4f80745f 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c +++ b/gcc/testsuite/gcc.dg/vect/vect-outer-3a.c @@ -49,6 +49,5 @@ int main (void) } /* { dg-final { scan-tree-dump-times "OUTER LOOP VECTORIZED" 1 "vect" { xfail vect_no_align } } } */ -/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 2 "vect" { target { ! vect_multiple_sizes } } } } */ -/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 3 "vect" { target vect_multiple_sizes } } } */ +/* { dg-final { scan-tree-dump-times "step doesn't divide the vector-size" 1 "vect" } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/extr.c b/gcc/testsuite/gcc.target/aarch64/extr.c new file mode 100644 index 00000000000..a78dd8d607b --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/extr.c @@ -0,0 +1,34 @@ +/* { dg-options "-O2 --save-temps" } */ +/* { dg-do run } */ + +extern void abort (void); + +int +test_si (int a, int b) +{ + /* { dg-final { scan-assembler "extr\tw\[0-9\]+, w\[0-9\]+, w\[0-9\]+, 27\n" } } */ + return (a << 5) | ((unsigned int) b >> 27); +} + +long long +test_di (long long a, long long b) +{ + /* { dg-final { scan-assembler "extr\tx\[0-9\]+, x\[0-9\]+, x\[0-9\]+, 45\n" } } */ + return (a << 19) | ((unsigned long long) b >> 45); +} + +int +main () +{ + int v; + long long w; + v = test_si (0x00000004, 0x30000000); + if (v != 0x00000086) + abort(); + w = test_di (0x0001040040040004ll, 0x0070050066666666ll); + if (w != 0x2002002000200380ll) + abort(); + return 0; +} + +/* { dg-final { cleanup-saved-temps } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/movk.c b/gcc/testsuite/gcc.target/aarch64/movk.c new file mode 100644 index 00000000000..e4b22098c44 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/movk.c @@ -0,0 +1,31 @@ +/* { dg-do run } */ +/* { dg-options "-O2 --save-temps -fno-inline" } */ + +extern void abort (void); + +long long int +dummy_number_generator () +{ + /* { dg-final { scan-assembler "movk\tx\[0-9\]+, 0xefff, lsl 16" } } */ + /* { dg-final { scan-assembler "movk\tx\[0-9\]+, 0xc4cc, lsl 32" } } */ + /* { dg-final { scan-assembler "movk\tx\[0-9\]+, 0xfffe, lsl 48" } } */ + return -346565474575675; +} + +int +main (void) +{ + + long long int num = dummy_number_generator (); + if (num > 0) + abort (); + + /* { dg-final { scan-assembler "movk\tx\[0-9\]+, 0x4667, lsl 16" } } */ + /* { dg-final { scan-assembler "movk\tx\[0-9\]+, 0x7a3d, lsl 32" } } */ + if (num / 69313094915135 != -5) + abort (); + + return 0; +} + +/* { dg-final { cleanup-saved-temps } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/ror.c b/gcc/testsuite/gcc.target/aarch64/ror.c new file mode 100644 index 00000000000..4d266f00471 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/ror.c @@ -0,0 +1,34 @@ +/* { dg-options "-O2 --save-temps" } */ +/* { dg-do run } */ + +extern void abort (void); + +int +test_si (int a) +{ + /* { dg-final { scan-assembler "ror\tw\[0-9\]+, w\[0-9\]+, 27\n" } } */ + return (a << 5) | ((unsigned int) a >> 27); +} + +long long +test_di (long long a) +{ + /* { dg-final { scan-assembler "ror\tx\[0-9\]+, x\[0-9\]+, 45\n" } } */ + return (a << 19) | ((unsigned long long) a >> 45); +} + +int +main () +{ + int v; + long long w; + v = test_si (0x0203050); + if (v != 0x4060a00) + abort(); + w = test_di (0x0000020506010304ll); + if (w != 0x1028300818200000ll) + abort(); + return 0; +} + +/* { dg-final { cleanup-saved-temps } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/sbc.c b/gcc/testsuite/gcc.target/aarch64/sbc.c new file mode 100644 index 00000000000..e479910bc2c --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/sbc.c @@ -0,0 +1,41 @@ +/* { dg-do run } */ +/* { dg-options "-O2 --save-temps" } */ + +extern void abort (void); + +typedef unsigned int u32int; +typedef unsigned long long u64int; + +u32int +test_si (u32int w1, u32int w2, u32int w3, u32int w4) +{ + u32int w0; + /* { dg-final { scan-assembler "sbc\tw\[0-9\]+, w\[0-9\]+, w\[0-9\]+\n" } } */ + w0 = w1 - w2 - (w3 < w4); + return w0; +} + +u64int +test_di (u64int x1, u64int x2, u64int x3, u64int x4) +{ + u64int x0; + /* { dg-final { scan-assembler "sbc\tx\[0-9\]+, x\[0-9\]+, x\[0-9\]+\n" } } */ + x0 = x1 - x2 - (x3 < x4); + return x0; +} + +int +main () +{ + u32int x; + u64int y; + x = test_si (7, 8, 12, 15); + if (x != -2) + abort(); + y = test_di (0x987654321ll, 0x123456789ll, 0x345345345ll, 0x123123123ll); + if (y != 0x8641fdb98ll) + abort(); + return 0; +} + +/* { dg-final { cleanup-saved-temps } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-compile.c b/gcc/testsuite/gcc.target/aarch64/vect-compile.c index 260c1e041c0..33130aab55d 100644 --- a/gcc/testsuite/gcc.target/aarch64/vect-compile.c +++ b/gcc/testsuite/gcc.target/aarch64/vect-compile.c @@ -16,5 +16,7 @@ /* { dg-final { scan-assembler "uminv" } } */ /* { dg-final { scan-assembler "smaxv" } } */ /* { dg-final { scan-assembler "sminv" } } */ +/* { dg-final { scan-assembler "sabd" } } */ +/* { dg-final { scan-assembler "saba" } } */ /* { dg-final { scan-assembler-times "addv" 2} } */ /* { dg-final { scan-assembler-times "addp" 2} } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-fp-compile.c b/gcc/testsuite/gcc.target/aarch64/vect-fp-compile.c index b953dfae3b8..47ef100e87b 100644 --- a/gcc/testsuite/gcc.target/aarch64/vect-fp-compile.c +++ b/gcc/testsuite/gcc.target/aarch64/vect-fp-compile.c @@ -11,3 +11,4 @@ /* { dg-final { scan-assembler "fdiv\\tv" } } */ /* { dg-final { scan-assembler "fneg\\tv" } } */ /* { dg-final { scan-assembler "fabs\\tv" } } */ +/* { dg-final { scan-assembler "fabd\\tv" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-fp.c b/gcc/testsuite/gcc.target/aarch64/vect-fp.c index a7357b7f065..bcf9d9d7530 100644 --- a/gcc/testsuite/gcc.target/aarch64/vect-fp.c +++ b/gcc/testsuite/gcc.target/aarch64/vect-fp.c @@ -117,6 +117,16 @@ int main (void) 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0 }; + F32 fabd_F32_vector[] = { 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f }; + + F64 fabd_F64_vector[] = { 1.0, 1.0, 1.0, 1.0, + 1.0, 1.0, 1.0, 1.0, + 1.0, 1.0, 1.0, 1.0, + 1.0, 1.0, 1.0, 1.0 }; + /* Setup input vectors. */ for (i=1; i<=16; i++) { @@ -132,6 +142,7 @@ int main (void) TEST (div, 3); TEST (neg, 2); TEST (abs, 2); + TEST (fabd, 3); return 0; } diff --git a/gcc/testsuite/gcc.target/aarch64/vect-fp.x b/gcc/testsuite/gcc.target/aarch64/vect-fp.x index 338f6edf945..82d1b1c50ee 100644 --- a/gcc/testsuite/gcc.target/aarch64/vect-fp.x +++ b/gcc/testsuite/gcc.target/aarch64/vect-fp.x @@ -7,13 +7,23 @@ typedef double *__restrict__ pRF64; extern float fabsf (float); extern double fabs (double); +#define DEF3a(fname, type, op) \ + void fname##_##type (pR##type a, \ + pR##type b, \ + pR##type c) \ + { \ + int i; \ + for (i = 0; i < 16; i++) \ + a[i] = op (b[i] - c[i]); \ + } + #define DEF3(fname, type, op) \ void fname##_##type (pR##type a, \ pR##type b, \ pR##type c) \ { \ int i; \ - for (i=0; i<16; i++) \ + for (i = 0; i < 16; i++) \ a[i] = b[i] op c[i]; \ } @@ -22,11 +32,15 @@ extern double fabs (double); pR##type b) \ { \ int i; \ - for (i=0; i<16; i++) \ + for (i = 0; i < 16; i++) \ a[i] = op(b[i]); \ } +#define DEFN3a(fname, op) \ + DEF3a (fname, F32, op) \ + DEF3a (fname, F64, op) + #define DEFN3(fname, op) \ DEF3 (fname, F32, op) \ DEF3 (fname, F64, op) @@ -42,3 +56,5 @@ DEFN3 (div, /) DEFN2 (neg, -) DEF2 (abs, F32, fabsf) DEF2 (abs, F64, fabs) +DEF3a (fabd, F32, fabsf) +DEF3a (fabd, F64, fabs) diff --git a/gcc/testsuite/gcc.target/aarch64/vect.c b/gcc/testsuite/gcc.target/aarch64/vect.c index fc4874440a0..ff70cae43b4 100644 --- a/gcc/testsuite/gcc.target/aarch64/vect.c +++ b/gcc/testsuite/gcc.target/aarch64/vect.c @@ -55,6 +55,8 @@ int main (void) int smin_vector[] = {0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15}; unsigned int umax_vector[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; unsigned int umin_vector[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; + int sabd_vector[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + int saba_vector[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; int reduce_smax_value = 0; int reduce_smin_value = -15; unsigned int reduce_umax_value = 15; @@ -81,6 +83,8 @@ int main (void) TEST (smin, s); TEST (umax, u); TEST (umin, u); + TEST (sabd, s); + TEST (saba, s); TESTV (reduce_smax, s); TESTV (reduce_smin, s); TESTV (reduce_umax, u); diff --git a/gcc/testsuite/gcc.target/aarch64/vect.x b/gcc/testsuite/gcc.target/aarch64/vect.x index 88078349750..c0f79b50b80 100644 --- a/gcc/testsuite/gcc.target/aarch64/vect.x +++ b/gcc/testsuite/gcc.target/aarch64/vect.x @@ -138,3 +138,17 @@ long long reduce_add_s64 (pRINT64 a) return s; } + +void sabd (pRINT a, pRINT b, pRINT c) +{ + int i; + for (i = 0; i < 16; i++) + c[i] = abs (a[i] - b[i]); +} + +void saba (pRINT a, pRINT b, pRINT c) +{ + int i; + for (i = 0; i < 16; i++) + c[i] += abs (a[i] - b[i]); +} diff --git a/gcc/testsuite/gcc.target/arm/neon-for-64bits-1.c b/gcc/testsuite/gcc.target/arm/neon-for-64bits-1.c new file mode 100644 index 00000000000..a2a4103b9a2 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/neon-for-64bits-1.c @@ -0,0 +1,54 @@ +/* Check that Neon is *not* used by default to handle 64-bits scalar + operations. */ + +/* { dg-do compile } */ +/* { dg-require-effective-target arm_neon_ok } */ +/* { dg-options "-O2" } */ +/* { dg-add-options arm_neon } */ + +typedef long long i64; +typedef unsigned long long u64; +typedef unsigned int u32; +typedef int i32; + +/* Unary operators */ +#define UNARY_OP(name, op) \ + void unary_##name(u64 *a, u64 *b) { *a = op (*b + 0x1234567812345678ULL) ; } + +/* Binary operators */ +#define BINARY_OP(name, op) \ + void binary_##name(u64 *a, u64 *b, u64 *c) { *a = *b op *c ; } + +/* Unsigned shift */ +#define SHIFT_U(name, op, amount) \ + void ushift_##name(u64 *a, u64 *b, int c) { *a = *b op amount; } + +/* Signed shift */ +#define SHIFT_S(name, op, amount) \ + void sshift_##name(i64 *a, i64 *b, int c) { *a = *b op amount; } + +UNARY_OP(not, ~) + +BINARY_OP(add, +) +BINARY_OP(sub, -) +BINARY_OP(and, &) +BINARY_OP(or, |) +BINARY_OP(xor, ^) + +SHIFT_U(right1, >>, 1) +SHIFT_U(right2, >>, 2) +SHIFT_U(right5, >>, 5) +SHIFT_U(rightn, >>, c) + +SHIFT_S(right1, >>, 1) +SHIFT_S(right2, >>, 2) +SHIFT_S(right5, >>, 5) +SHIFT_S(rightn, >>, c) + +/* { dg-final {scan-assembler-times "vmvn" 0} } */ +/* { dg-final {scan-assembler-times "vadd" 0} } */ +/* { dg-final {scan-assembler-times "vsub" 0} } */ +/* { dg-final {scan-assembler-times "vand" 0} } */ +/* { dg-final {scan-assembler-times "vorr" 0} } */ +/* { dg-final {scan-assembler-times "veor" 0} } */ +/* { dg-final {scan-assembler-times "vshr" 0} } */ diff --git a/gcc/testsuite/gcc.target/arm/neon-for-64bits-2.c b/gcc/testsuite/gcc.target/arm/neon-for-64bits-2.c new file mode 100644 index 00000000000..035bfb77a37 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/neon-for-64bits-2.c @@ -0,0 +1,57 @@ +/* Check that Neon is used to handle 64-bits scalar operations. */ + +/* { dg-do compile } */ +/* { dg-require-effective-target arm_neon_ok } */ +/* { dg-options "-O2 -mneon-for-64bits" } */ +/* { dg-add-options arm_neon } */ + +typedef long long i64; +typedef unsigned long long u64; +typedef unsigned int u32; +typedef int i32; + +/* Unary operators */ +#define UNARY_OP(name, op) \ + void unary_##name(u64 *a, u64 *b) { *a = op (*b + 0x1234567812345678ULL) ; } + +/* Binary operators */ +#define BINARY_OP(name, op) \ + void binary_##name(u64 *a, u64 *b, u64 *c) { *a = *b op *c ; } + +/* Unsigned shift */ +#define SHIFT_U(name, op, amount) \ + void ushift_##name(u64 *a, u64 *b, int c) { *a = *b op amount; } + +/* Signed shift */ +#define SHIFT_S(name, op, amount) \ + void sshift_##name(i64 *a, i64 *b, int c) { *a = *b op amount; } + +UNARY_OP(not, ~) + +BINARY_OP(add, +) +BINARY_OP(sub, -) +BINARY_OP(and, &) +BINARY_OP(or, |) +BINARY_OP(xor, ^) + +SHIFT_U(right1, >>, 1) +SHIFT_U(right2, >>, 2) +SHIFT_U(right5, >>, 5) +SHIFT_U(rightn, >>, c) + +SHIFT_S(right1, >>, 1) +SHIFT_S(right2, >>, 2) +SHIFT_S(right5, >>, 5) +SHIFT_S(rightn, >>, c) + +/* { dg-final {scan-assembler-times "vmvn" 1} } */ +/* Two vadd: 1 in unary_not, 1 in binary_add */ +/* { dg-final {scan-assembler-times "vadd" 2} } */ +/* { dg-final {scan-assembler-times "vsub" 1} } */ +/* { dg-final {scan-assembler-times "vand" 1} } */ +/* { dg-final {scan-assembler-times "vorr" 1} } */ +/* { dg-final {scan-assembler-times "veor" 1} } */ +/* 6 vshr for right shifts by constant, and variable right shift uses + vshl with a negative amount in register. */ +/* { dg-final {scan-assembler-times "vshr" 6} } */ +/* { dg-final {scan-assembler-times "vshl" 2} } */ diff --git a/gcc/testsuite/gcc.target/arm/neon-vcond-gt.c b/gcc/testsuite/gcc.target/arm/neon-vcond-gt.c new file mode 100644 index 00000000000..86ccf95ada6 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/neon-vcond-gt.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_neon_ok } */ +/* { dg-options "-O1 -funsafe-math-optimizations -ftree-vectorize" } */ +/* { dg-add-options arm_neon } */ + +#define MAX(a, b) (a > b ? a : b) +void foo (int ilast,float* w, float* w2) +{ + int i; + for (i = 0; i < ilast; ++i) + { + w[i] = MAX (0.0f, w2[i]); + } +} + +/* { dg-final { scan-assembler "vcgt\\.f32\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" } } */ +/* { dg-final { scan-assembler "vbit\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" } } */ diff --git a/gcc/testsuite/gcc.target/arm/neon-vcond-ltgt.c b/gcc/testsuite/gcc.target/arm/neon-vcond-ltgt.c new file mode 100644 index 00000000000..acb23a947ff --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/neon-vcond-ltgt.c @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_neon_ok } */ +/* { dg-options "-O1 -funsafe-math-optimizations -ftree-vectorize" } */ +/* { dg-add-options arm_neon } */ + +#define LTGT(a, b) (__builtin_islessgreater (a, b) ? a : b) +void foo (int ilast,float* w, float* w2) +{ + int i; + for (i = 0; i < ilast; ++i) + { + w[i] = LTGT (0.0f, w2[i]); + } +} + +/* { dg-final { scan-assembler-times "vcgt\\.f32\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" 2 } } */ +/* { dg-final { scan-assembler "vorr\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" } } */ +/* { dg-final { scan-assembler "vbsl\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" } } */ diff --git a/gcc/testsuite/gcc.target/arm/neon-vcond-unordered.c b/gcc/testsuite/gcc.target/arm/neon-vcond-unordered.c new file mode 100644 index 00000000000..c3e448d621b --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/neon-vcond-unordered.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_neon_ok } */ +/* { dg-options "-O1 -funsafe-math-optimizations -ftree-vectorize" } */ +/* { dg-add-options arm_neon } */ + +#define UNORD(a, b) (__builtin_isunordered (a, b) ? a : b) +void foo (int ilast,float* w, float* w2) +{ + int i; + for (i = 0; i < ilast; ++i) + { + w[i] = UNORD (0.0f, w2[i]); + } +} + +/* { dg-final { scan-assembler "vcgt\\.f32\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" } } */ +/* { dg-final { scan-assembler "vcge\\.f32\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" } } */ +/* { dg-final { scan-assembler "vorr\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" } } */ +/* { dg-final { scan-assembler "vbsl\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+,\[\\t \]*q\[0-9\]+" } } */ diff --git a/gcc/testsuite/gcc.target/i386/movti.c b/gcc/testsuite/gcc.target/i386/movti.c index e306c1e3f01..86a0279faa2 100644 --- a/gcc/testsuite/gcc.target/i386/movti.c +++ b/gcc/testsuite/gcc.target/i386/movti.c @@ -7,4 +7,4 @@ _Decimal128 test (void) return 1234123412341234.123412341234dl; } -/* { dg-final { scan-assembler-not "movabs" } } */ +/* { dg-final { scan-assembler-not "movabs" { target { ! x86_64-*-mingw* } } } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr20020-1.c b/gcc/testsuite/gcc.target/i386/pr20020-1.c index 3f10970a943..f36a8a0953d 100644 --- a/gcc/testsuite/gcc.target/i386/pr20020-1.c +++ b/gcc/testsuite/gcc.target/i386/pr20020-1.c @@ -1,5 +1,6 @@ /* Check that 128-bit struct's are represented as TImode values. */ /* { dg-do compile { target int128 } } */ +/* { dg-skip-if "different ABI" { x86_64-*-mingw* } } */ /* { dg-options "-O2 -fdump-rtl-expand" } */ struct shared_ptr_struct diff --git a/gcc/testsuite/gcc.target/i386/pr20020-2.c b/gcc/testsuite/gcc.target/i386/pr20020-2.c index e8c5b3d06a4..fa5b6edaf81 100644 --- a/gcc/testsuite/gcc.target/i386/pr20020-2.c +++ b/gcc/testsuite/gcc.target/i386/pr20020-2.c @@ -1,5 +1,6 @@ /* Check that 128-bit struct's are represented as TImode values. */ /* { dg-do compile { target int128 } } */ +/* { dg-skip-if "different ABI" { x86_64-*-mingw* } } */ /* { dg-options "-O2 -fdump-rtl-expand" } */ struct shared_ptr_struct diff --git a/gcc/testsuite/gcc.target/i386/pr20020-3.c b/gcc/testsuite/gcc.target/i386/pr20020-3.c index b1cc9260ec8..a30fbc4b11c 100644 --- a/gcc/testsuite/gcc.target/i386/pr20020-3.c +++ b/gcc/testsuite/gcc.target/i386/pr20020-3.c @@ -1,5 +1,6 @@ /* Check that 128-bit struct's are represented as TImode values. */ /* { dg-do compile { target int128 } } */ +/* { dg-skip-if "different ABI" { x86_64-*-mingw* } } */ /* { dg-options "-O2 -fdump-rtl-expand" } */ struct shared_ptr_struct diff --git a/gcc/testsuite/gcc.target/i386/pr22152.c b/gcc/testsuite/gcc.target/i386/pr22152.c index 0b00169d026..b20a22a4c90 100644 --- a/gcc/testsuite/gcc.target/i386/pr22152.c +++ b/gcc/testsuite/gcc.target/i386/pr22152.c @@ -1,6 +1,6 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -msse2" } */ -/* { dg-options "-O2 -msse2 -mno-vect8-ret-in-mem" { target i?86-*-solaris2.9 *-*-vxworks* } } */ +/* { dg-options "-O2 -msse2 -mtune=core2" } */ +/* { dg-additional-options "-mno-vect8-ret-in-mem" { target i?86-*-solaris2.9 *-*-vxworks* } } */ /* { dg-additional-options "-mabi=sysv" { target x86_64-*-mingw* } } */ #include <mmintrin.h> diff --git a/gcc/testsuite/gcc.target/i386/pr53425-1.c b/gcc/testsuite/gcc.target/i386/pr53425-1.c index 2446c0f5419..00143f32ab3 100644 --- a/gcc/testsuite/gcc.target/i386/pr53425-1.c +++ b/gcc/testsuite/gcc.target/i386/pr53425-1.c @@ -1,6 +1,7 @@ /* PR target/53425 */ /* { dg-do compile { target { ! { ia32 } } } } */ /* { dg-options "-O2 -mno-sse" } */ +/* { dg-skip-if "no SSE vector" { x86_64-*-mingw* } } */ typedef double __v2df __attribute__ ((__vector_size__ (16))); diff --git a/gcc/testsuite/gcc.target/i386/pr53425-2.c b/gcc/testsuite/gcc.target/i386/pr53425-2.c index b89a5b1fa8c..97523f35bb5 100644 --- a/gcc/testsuite/gcc.target/i386/pr53425-2.c +++ b/gcc/testsuite/gcc.target/i386/pr53425-2.c @@ -1,6 +1,7 @@ /* PR target/53425 */ /* { dg-do compile { target { ! { ia32 } } } } */ /* { dg-options "-O2 -mno-sse" } */ +/* { dg-skip-if "no SSE vector" { x86_64-*-mingw* } } */ typedef float __v2sf __attribute__ ((__vector_size__ (8))); diff --git a/gcc/testsuite/gcc.target/i386/pr53907.c b/gcc/testsuite/gcc.target/i386/pr53907.c index 8de8f0de985..27e2e02985f 100644 --- a/gcc/testsuite/gcc.target/i386/pr53907.c +++ b/gcc/testsuite/gcc.target/i386/pr53907.c @@ -3,10 +3,12 @@ #include <emmintrin.h> +__extension__ typedef __UINTPTR_TYPE__ uintptr_t; + __m128i x(char *s) { __m128i sz,z,mvec; - s-=((unsigned long) s)%16; + s-=((uintptr_t) s)%16; sz=_mm_load_si128((__m128i *)s); return sz; } diff --git a/gcc/testsuite/gcc.target/i386/pr55093.c b/gcc/testsuite/gcc.target/i386/pr55093.c index 76b4042302f..3d32a5799d7 100644 --- a/gcc/testsuite/gcc.target/i386/pr55093.c +++ b/gcc/testsuite/gcc.target/i386/pr55093.c @@ -1,5 +1,6 @@ /* { dg-do compile { target { ! { ia32 } } } } */ /* { dg-options "-O2 -mx32 -maddress-mode=long" } */ +/* { dg-skip-if "different ABI" { x86_64-*-mingw* } } */ typedef union tree_node *tree; typedef const union tree_node *const_tree; diff --git a/gcc/testsuite/gcc.target/mips/mips.exp b/gcc/testsuite/gcc.target/mips/mips.exp index ad32fb67713..15b1386bd9e 100644 --- a/gcc/testsuite/gcc.target/mips/mips.exp +++ b/gcc/testsuite/gcc.target/mips/mips.exp @@ -238,6 +238,7 @@ set mips_option_groups { fp "-mfp(32|64)" gp "-mgp(32|64)" long "-mlong(32|64)" + micromips "-mmicromips|-mno-micromips" mips16 "-mips16|-mno-mips16|-mflip-mips16" mips3d "-mips3d|-mno-mips3d" pic "-f(no-|)(pic|PIC)" @@ -816,6 +817,8 @@ proc mips-dg-finish {} { # | | # -mips16/-mflip-mips16 -mno-mips16 # | | +# -micromips -mno-micromips +# | | # -mips3d -mno-mips3d # | | # -mpaired-single -mno-paired-single @@ -904,6 +907,8 @@ proc mips-dg-options { args } { # Handle dependencies between options on the left of the # dependency diagram. + mips_option_dependency options "-mips16" "-mno-micromips" + mips_option_dependency options "-mmicromips" "-mno-mips16" mips_option_dependency options "-mips3d" "-mpaired-single" mips_option_dependency options "-mpaired-single" "-mfp64" mips_option_dependency options "-mfp64" "-mhard-float" @@ -1246,6 +1251,10 @@ proc mips-dg-options { args } { append extra_tool_flags " -DMIPS16=__attribute__((mips16))" } + if { [mips_have_test_option_p options "-mmicromips"] } { + append extra_tool_flags " -DMICROMIPS=__attribute__((micromips))" + } + # Use our version of gcc-dg-test for this test. if { ![string equal [info procs "mips-gcc-dg-test"] ""] } { rename gcc-dg-test mips-old-gcc-dg-test @@ -1275,6 +1284,6 @@ proc mips-gcc-dg-test { prog do_what extra_tool_flags } { dg-init mips-dg-init gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.c]] \ - "-DNOMIPS16=__attribute__((nomips16))" + "-DNOMIPS16=__attribute__((nomips16)) -DNOMICROMIPS=__attribute__((nomicromips)) -DNOCOMPRESSION=__attribute__((nocompression))" mips-dg-finish dg-finish diff --git a/gcc/testsuite/gcc.target/mips/umips-constraints-1.c b/gcc/testsuite/gcc.target/mips/umips-constraints-1.c index e69de29bb2d..ddec815b0f3 100644 --- a/gcc/testsuite/gcc.target/mips/umips-constraints-1.c +++ b/gcc/testsuite/gcc.target/mips/umips-constraints-1.c @@ -0,0 +1,14 @@ +/* { dg-options "(-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +MICROMIPS void +foo (int *x) +{ + asm volatile ("insn1\t%a0" :: "ZD" (&x[0])); + asm volatile ("insn2\t%a0" :: "ZD" (&x[511])); + asm volatile ("insn3\t%a0" :: "ZD" (&x[512])); +} + +/* { dg-final { scan-assembler "\tinsn1\t0\\(" } } */ +/* { dg-final { scan-assembler "\tinsn2\t2044\\(" } } */ +/* { dg-final { scan-assembler-not "\tinsn3\t2048\\(" } } */ diff --git a/gcc/testsuite/gcc.target/mips/umips-constraints-2.c b/gcc/testsuite/gcc.target/mips/umips-constraints-2.c index e69de29bb2d..0240d467026 100644 --- a/gcc/testsuite/gcc.target/mips/umips-constraints-2.c +++ b/gcc/testsuite/gcc.target/mips/umips-constraints-2.c @@ -0,0 +1,14 @@ +/* { dg-options "(-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +MICROMIPS void +foo (int *x) +{ + asm volatile ("insn1\t%0" :: "ZC" (x[0])); + asm volatile ("insn2\t%0" :: "ZC" (x[511])); + asm volatile ("insn3\t%0" :: "ZC" (x[512])); +} + +/* { dg-final { scan-assembler "\tinsn1\t0\\(" } } */ +/* { dg-final { scan-assembler "\tinsn2\t2044\\(" } } */ +/* { dg-final { scan-assembler-not "\tinsn3\t2048\\(" } } */ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-1.c b/gcc/testsuite/gcc.target/mips/umips-lwp-1.c index e69de29bb2d..0cdb1b7f2bc 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-1.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-1.c @@ -0,0 +1,17 @@ +/* { dg-options "-mgp32 -fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4) +{ + int r5 = r4[0]; + int r6 = r4[1]; + r4[2] = r5 * r5; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[3]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler "\tlwp\t\\\$5,0\\(\\\$4\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-2.c b/gcc/testsuite/gcc.target/mips/umips-lwp-2.c index e69de29bb2d..ea3f3960742 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-2.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-2.c @@ -0,0 +1,17 @@ +/* { dg-options "-mgp32 -fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4) +{ + int r5 = r4[0]; + int r6 = r4[1]; + r4[2] = r6 * r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[3]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler "\tlwp\t\\\$5,0\\(\\\$4\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-3.c b/gcc/testsuite/gcc.target/mips/umips-lwp-3.c index e69de29bb2d..2cb37510feb 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-3.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-3.c @@ -0,0 +1,17 @@ +/* { dg-options "-mgp32 -fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4) +{ + int r5 = r4[511]; + int r6 = r4[512]; + r4[2] = r5 * r5; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[3]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler "\tlwp\t\\\$5,2044\\(\\\$4\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-4.c b/gcc/testsuite/gcc.target/mips/umips-lwp-4.c index e69de29bb2d..b8a86b4ed90 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-4.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-4.c @@ -0,0 +1,17 @@ +/* { dg-options "-mgp32 -fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4) +{ + int r5 = r4[511]; + int r6 = r4[512]; + r4[2] = r6 * r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[3]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler "\tlwp\t\\\$5,2044\\(\\\$4\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-5.c b/gcc/testsuite/gcc.target/mips/umips-lwp-5.c index e69de29bb2d..2315f21e91e 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-5.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-5.c @@ -0,0 +1,17 @@ +/* { dg-options "-mgp32 -fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4) +{ + int r5 = r4[512]; + int r6 = r4[513]; + r4[2] = r5 * r5; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[3]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler-not "\tlwp" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-6.c b/gcc/testsuite/gcc.target/mips/umips-lwp-6.c index e69de29bb2d..9534974de8f 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-6.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-6.c @@ -0,0 +1,17 @@ +/* { dg-options "-mgp32 -fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4) +{ + int r5 = r4[512]; + int r6 = r4[513]; + r4[2] = r6 * r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[3]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler-not "\tlwp" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-7.c b/gcc/testsuite/gcc.target/mips/umips-lwp-7.c index e69de29bb2d..87ff6dc1154 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-7.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-7.c @@ -0,0 +1,41 @@ +/* { dg-options "-mgp32 -fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +f1 (int *r4, int dummy, int *other) +{ + int r5 = r4[1]; + int newr4 = r4[0]; + other[0] = r5 * r5; + { + register int r5asm asm ("$5") = r5; + register int r4asm asm ("$4") = newr4; + asm ("#foo" : "=m" (other[1]) : "d" (r4asm), "d" (r5asm)); + } +} + +void MICROMIPS +f2 (int *r4, int dummy, int *other) +{ + int newr4 = r4[0]; + int r5 = *(int *)(newr4 + 4); + { + register int r5asm asm ("$5") = r5; + register int r4asm asm ("$4") = newr4; + asm ("#foo" : "=m" (other[0]) : "d" (r4asm), "d" (r5asm)); + } +} + +void MICROMIPS +f3 (int dummy, int *r5, int *other) +{ + int newr5 = r5[1]; + int r4 = *(int *)newr5; + { + register int r5asm asm ("$4") = r4; + register int r4asm asm ("$5") = newr5; + asm ("#foo" : "=m" (other[0]) : "d" (r4asm), "d" (r5asm)); + } +} + +/* { dg-final { scan-assembler-not "\tlwp" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-8.c b/gcc/testsuite/gcc.target/mips/umips-lwp-8.c index e69de29bb2d..43b98423dfd 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-8.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-8.c @@ -0,0 +1,17 @@ +/* { dg-options "-mgp32 -fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +f1 (int dummy, int *r5, int *other) +{ + int r4 = r5[0]; + int newr5 = r5[1]; + other[0] = r4 * r4; + { + register int r5asm asm ("$4") = r4; + register int r4asm asm ("$5") = newr5; + asm ("#foo" : "=m" (other[1]) : "d" (r4asm), "d" (r5asm)); + } +} + +/* { dg-final { scan-assembler "\tlwp\t\\\$4,0\\(\\\$5\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-lwp-swp-volatile.c b/gcc/testsuite/gcc.target/mips/umips-lwp-swp-volatile.c index e69de29bb2d..da2cbaff38b 100644 --- a/gcc/testsuite/gcc.target/mips/umips-lwp-swp-volatile.c +++ b/gcc/testsuite/gcc.target/mips/umips-lwp-swp-volatile.c @@ -0,0 +1,42 @@ +/* { dg-do compile } */ +/* { dg-options "-mmicromips" } */ + +/* This test ensures that we do not generate microMIPS SWP or LWP + instructions when any component of the accessed memory is volatile; + they are unsafe for such since they might cause replay of partial + accesses if interrupted by an exception. */ + +static void set_csr (volatile void *p, int v) +{ + *(volatile int *) (p) = v; +} + +static int get_csr (volatile void *p) +{ + return *(volatile int *) (p); +} + +int main () +{ + int i, q = 0, p = 0, r = 0; + + for (i = 0; i < 20; i++) + { + set_csr ((volatile void *) 0xbf0100a8, 0xffff0002); + set_csr ((volatile void *) 0xbf0100a4, 0x80000008); + } + + for (i = 0; i < 20; i++) + { + register int k, j; + k = get_csr ((volatile void *) 0xbf0100b8); + p += k; + j = get_csr ((volatile void *) 0xbf0100b4); + r += j; + q = j + k; + } + return q + r + p; +} + +/* { dg-final { scan-assembler-not "\tswp" } } */ +/* { dg-final { scan-assembler-not "\tlwp" } } */ diff --git a/gcc/testsuite/gcc.target/mips/umips-movep-1.c b/gcc/testsuite/gcc.target/mips/umips-movep-1.c index e69de29bb2d..0865b78bd8c 100644 --- a/gcc/testsuite/gcc.target/mips/umips-movep-1.c +++ b/gcc/testsuite/gcc.target/mips/umips-movep-1.c @@ -0,0 +1,16 @@ +/* Check that we can generate the MOVEP instruction. */ +/* { dg-options "-mgp32 -fpeephole2 (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +long long bar (long long, long long); + +MICROMIPS long long +foo (long long n, long long a) +{ + long long i, j; + + i = bar (n, a); + j = bar (n, a); + return i + j; +} +/* { dg-final { scan-assembler "\tmovep\t" } } */ diff --git a/gcc/testsuite/gcc.target/mips/umips-movep-2.c b/gcc/testsuite/gcc.target/mips/umips-movep-2.c index e69de29bb2d..5a3a8419eee 100644 --- a/gcc/testsuite/gcc.target/mips/umips-movep-2.c +++ b/gcc/testsuite/gcc.target/mips/umips-movep-2.c @@ -0,0 +1,13 @@ +/* Check that we can generate the MOVEP instruction. */ +/* { dg-options "-fpeephole2 -mgp32 (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +int bar (int, int); + +int MICROMIPS +foo (int n, int a) +{ + return bar (0, 0); +} + +/* { dg-final { scan-assembler "\tmovep\t\\\$4,\\\$5,\\\$0,\\\$0" } } */ diff --git a/gcc/testsuite/gcc.target/mips/umips-save-restore-1.c b/gcc/testsuite/gcc.target/mips/umips-save-restore-1.c index e69de29bb2d..ff1ea4b339a 100644 --- a/gcc/testsuite/gcc.target/mips/umips-save-restore-1.c +++ b/gcc/testsuite/gcc.target/mips/umips-save-restore-1.c @@ -0,0 +1,18 @@ +/* Check that we can use the swm/lwm instructions. */ +/* { dg-options "-mabi=32 (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +int bar (int, int, int, int, int); + +MICROMIPS int +foo (int n, int a, int b, int c, int d) +{ + int i, j; + + i = bar (n, a, b, c, d); + j = bar (n, a, b, c, d); + return i + j; +} + +/* { dg-final { scan-assembler "\tswm\t\\\$16-\\\$2(0|1),\\\$31" } } */ +/* { dg-final { scan-assembler "\tlwm\t\\\$16-\\\$2(0|1),\\\$31" } } */ diff --git a/gcc/testsuite/gcc.target/mips/umips-save-restore-2.c b/gcc/testsuite/gcc.target/mips/umips-save-restore-2.c index e69de29bb2d..cb421d5d4be 100644 --- a/gcc/testsuite/gcc.target/mips/umips-save-restore-2.c +++ b/gcc/testsuite/gcc.target/mips/umips-save-restore-2.c @@ -0,0 +1,16 @@ +/* Check that we can use the save instruction to save spilled arguments. */ +/* { dg-options "-mabi=32 (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +MICROMIPS void +foo (int *a, int b, int c) +{ + asm volatile ("" ::: "$2", "$3", "$4", "$5", "$6", "$7", "$8", + "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$16", + "$17", "$18", "$19", "$20", "$21", "$22", "$23", "$24", + "$25", "$30", "memory"); + a[b] = 1; + a[c] = 1; +} +/* { dg-final { scan-assembler "\tswm\t\\\$16-\\\$23,\\\$fp" } } */ +/* { dg-final { scan-assembler "\tlwm\t\\\$16-\\\$23,\\\$fp" } } */ diff --git a/gcc/testsuite/gcc.target/mips/umips-save-restore-3.c b/gcc/testsuite/gcc.target/mips/umips-save-restore-3.c index e69de29bb2d..22c6f45f717 100644 --- a/gcc/testsuite/gcc.target/mips/umips-save-restore-3.c +++ b/gcc/testsuite/gcc.target/mips/umips-save-restore-3.c @@ -0,0 +1,14 @@ +/* Check that we can use the swm instruction to save $16, $17 and $31. */ +/* { dg-options "-mgp32 (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void bar (void); + +MICROMIPS void +foo (void) +{ + bar (); + asm volatile ("" ::: "$16", "$17"); +} +/* { dg-final { scan-assembler "\tswm\t\\\$16-\\\$17,\\\$31" } } */ +/* { dg-final { scan-assembler "\tlwm\t\\\$16-\\\$17,\\\$31" } } */ diff --git a/gcc/testsuite/gcc.target/mips/umips-swp-1.c b/gcc/testsuite/gcc.target/mips/umips-swp-1.c index e69de29bb2d..5e337b27b6c 100644 --- a/gcc/testsuite/gcc.target/mips/umips-swp-1.c +++ b/gcc/testsuite/gcc.target/mips/umips-swp-1.c @@ -0,0 +1,10 @@ +/* { dg-options "-fpeephole2 -mgp32 (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (long long l1, long long *l2) +{ + *l2 = l1; +} + +/* { dg-final { scan-assembler "\tswp\t\\\$4,0\\(\\\$6\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-swp-2.c b/gcc/testsuite/gcc.target/mips/umips-swp-2.c index e69de29bb2d..042322c2175 100644 --- a/gcc/testsuite/gcc.target/mips/umips-swp-2.c +++ b/gcc/testsuite/gcc.target/mips/umips-swp-2.c @@ -0,0 +1,17 @@ +/* { dg-options "-fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4, int r5, int r6) +{ + r6 *= r6; + r4[0] = r5; + r4[1] = r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[2]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler "\tswp\t\\\$5,0\\(\\\$4\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-swp-3.c b/gcc/testsuite/gcc.target/mips/umips-swp-3.c index e69de29bb2d..f0e54647d9c 100644 --- a/gcc/testsuite/gcc.target/mips/umips-swp-3.c +++ b/gcc/testsuite/gcc.target/mips/umips-swp-3.c @@ -0,0 +1,17 @@ +/* { dg-options "-fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4, int r5, int r6) +{ + r5 *= r5; + r4[0] = r5; + r4[1] = r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[2]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler "\tswp\t\\\$5,0\\(\\\$4\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-swp-4.c b/gcc/testsuite/gcc.target/mips/umips-swp-4.c index e69de29bb2d..5e8f5ea2a76 100644 --- a/gcc/testsuite/gcc.target/mips/umips-swp-4.c +++ b/gcc/testsuite/gcc.target/mips/umips-swp-4.c @@ -0,0 +1,17 @@ +/* { dg-options "-fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4, int r5, int r6) +{ + r6 *= r6; + r4[511] = r5; + r4[512] = r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[2]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler "\tswp\t\\\$5,2044\\(\\\$4\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-swp-5.c b/gcc/testsuite/gcc.target/mips/umips-swp-5.c index e69de29bb2d..dc1938e47b5 100644 --- a/gcc/testsuite/gcc.target/mips/umips-swp-5.c +++ b/gcc/testsuite/gcc.target/mips/umips-swp-5.c @@ -0,0 +1,17 @@ +/* { dg-options "-fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4, int r5, int r6) +{ + r5 *= r5; + r4[511] = r5; + r4[512] = r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[2]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler "\tswp\t\\\$5,2044\\(\\\$4\\)" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-swp-6.c b/gcc/testsuite/gcc.target/mips/umips-swp-6.c index e69de29bb2d..b489006ce99 100644 --- a/gcc/testsuite/gcc.target/mips/umips-swp-6.c +++ b/gcc/testsuite/gcc.target/mips/umips-swp-6.c @@ -0,0 +1,17 @@ +/* { dg-options "-fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4, int r5, int r6) +{ + r6 *= r6; + r4[512] = r5; + r4[513] = r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[2]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler-not "\tswp" } }*/ diff --git a/gcc/testsuite/gcc.target/mips/umips-swp-7.c b/gcc/testsuite/gcc.target/mips/umips-swp-7.c index e69de29bb2d..6dde49b8a35 100644 --- a/gcc/testsuite/gcc.target/mips/umips-swp-7.c +++ b/gcc/testsuite/gcc.target/mips/umips-swp-7.c @@ -0,0 +1,17 @@ +/* { dg-options "-fpeephole2 -mtune=m14k (-mmicromips)" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +void MICROMIPS +foo (int *r4, int r5, int r6) +{ + r5 *= r5; + r4[512] = r5; + r4[513] = r6; + { + register int r5asm asm ("$5") = r5; + register int r6asm asm ("$6") = r6; + asm ("#foo" : "=m" (r4[2]) : "d" (r5asm), "d" (r6asm)); + } +} + +/* { dg-final { scan-assembler-not "\tswp" } }*/ diff --git a/gcc/testsuite/gcc.target/powerpc/mmfpgpr.c b/gcc/testsuite/gcc.target/powerpc/mmfpgpr.c new file mode 100644 index 00000000000..7f2d3d3eff9 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/mmfpgpr.c @@ -0,0 +1,22 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power6x -mmfpgpr" } */ +/* { dg-final { scan-assembler "mffgpr" } } */ +/* { dg-final { scan-assembler "mftgpr" } } */ + +/* Test that we generate the instructions to move between the GPR and FPR + registers under power6x. */ + +extern long return_long (void); +extern double return_double (void); + +double return_double2 (void) +{ + return (double) return_long (); +} + +long return_long2 (void) +{ + return (long) return_double (); +} diff --git a/gcc/testsuite/gcc.target/powerpc/pr56605.c b/gcc/testsuite/gcc.target/powerpc/pr56605.c new file mode 100644 index 00000000000..7e5af449d05 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr56605.c @@ -0,0 +1,13 @@ +/* PR rtl-optimization/56605 */ +/* { dg-do compile { target { powerpc64-*-* && lp64 } } } */ +/* { dg-options "-O3 -mvsx -mcpu=power7 -fno-unroll-loops -fdump-rtl-loop2_doloop" } */ + +void foo (short* __restrict sb, int* __restrict ia) +{ + int i; + for (i = 0; i < 4000; i++) + ia[i] = (int) sb[i]; +} + +/* { dg-final { scan-rtl-dump-times "\\\(compare:CC \\\(subreg:SI \\\(reg:DI" 1 "loop2_doloop" } } */ +/* { dg-final { cleanup-rtl-dump "loop2_doloop" } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c b/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c new file mode 100644 index 00000000000..947382b7f7b --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c @@ -0,0 +1,19 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power6 -mhard-dfp" } */ +/* { dg-final { scan-assembler-not "lfiwzx" } } */ +/* { dg-final { scan-assembler-times "lfd" 2 } } */ +/* { dg-final { scan-assembler-times "dctdp" 2 } } */ +/* { dg-final { scan-assembler-times "dadd" 1 } } */ +/* { dg-final { scan-assembler-times "drsp" 1 } } */ + +/* Test that for power6 we need to use a bounce buffer on the stack to load + SDmode variables because the power6 does not have a way to directly load + 32-bit values from memory. */ +_Decimal32 a; + +void inc_dec32 (void) +{ + a += (_Decimal32) 1.0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/sd-vsx.c b/gcc/testsuite/gcc.target/powerpc/sd-vsx.c new file mode 100644 index 00000000000..7e41e1e84cc --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/sd-vsx.c @@ -0,0 +1,20 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power7 -mhard-dfp" } */ +/* { dg-final { scan-assembler-times "lfiwzx" 2 } } */ +/* { dg-final { scan-assembler-times "stfiwx" 1 } } */ +/* { dg-final { scan-assembler-not "lfd" } } */ +/* { dg-final { scan-assembler-not "stfd" } } */ +/* { dg-final { scan-assembler-times "dctdp" 2 } } */ +/* { dg-final { scan-assembler-times "dadd" 1 } } */ +/* { dg-final { scan-assembler-times "drsp" 1 } } */ + +/* Test that power7 can directly load/store SDmode variables without using a + bounce buffer. */ +_Decimal32 a; + +void inc_dec32 (void) +{ + a += (_Decimal32) 1.0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-float0.c b/gcc/testsuite/gcc.target/powerpc/vsx-float0.c new file mode 100644 index 00000000000..7e4fea68957 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-float0.c @@ -0,0 +1,16 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power7" } */ +/* { dg-final { scan-assembler "xxlxor" } } */ + +/* Test that we generate xxlor to clear a SFmode register. */ + +float sum (float *p, unsigned long n) +{ + float sum = 0.0f; /* generate xxlxor instead of load */ + while (n-- > 0) + sum += *p++; + + return sum; +} diff --git a/gcc/testsuite/gcc.target/sh/pr49880-1.c b/gcc/testsuite/gcc.target/sh/pr49880-1.c new file mode 100644 index 00000000000..e19f1bf38a1 --- /dev/null +++ b/gcc/testsuite/gcc.target/sh/pr49880-1.c @@ -0,0 +1,22 @@ +/* Check that the option -mdiv=call-div1 works. */ +/* { dg-do link { target "sh*-*-*" } } */ +/* { dg-options "-mdiv=call-div1" } */ +/* { dg-skip-if "" { "sh*-*-*" } { "-m5*"} { "" } } */ + +int +test00 (int a, int b) +{ + return a / b; +} + +unsigned int +test01 (unsigned int a, unsigned b) +{ + return a / b; +} + +int +main (int argc, char** argv) +{ + return test00 (argc, 123) + test01 (argc, 123); +} diff --git a/gcc/testsuite/gcc.target/sh/pr49880-2.c b/gcc/testsuite/gcc.target/sh/pr49880-2.c new file mode 100644 index 00000000000..eef832e30db --- /dev/null +++ b/gcc/testsuite/gcc.target/sh/pr49880-2.c @@ -0,0 +1,22 @@ +/* Check that the option -mdiv=call-fp works. */ +/* { dg-do link { target "sh*-*-*" } } */ +/* { dg-options "-mdiv=call-fp" } */ +/* { dg-skip-if "" { "sh*-*-*" } { "-m5*"} { "" } } */ + +int +test00 (int a, int b) +{ + return a / b; +} + +unsigned int +test01 (unsigned int a, unsigned b) +{ + return a / b; +} + +int +main (int argc, char** argv) +{ + return test00 (argc, 123) + test01 (argc, 123); +} diff --git a/gcc/testsuite/gcc.target/sh/pr49880-3.c b/gcc/testsuite/gcc.target/sh/pr49880-3.c new file mode 100644 index 00000000000..80a7df548a8 --- /dev/null +++ b/gcc/testsuite/gcc.target/sh/pr49880-3.c @@ -0,0 +1,22 @@ +/* Check that the option -mdiv=call-table works. */ +/* { dg-do link { target "sh*-*-*" } } */ +/* { dg-options "-mdiv=call-table" } */ +/* { dg-skip-if "" { "sh*-*-*" } { "-m5*"} { "" } } */ + +int +test00 (int a, int b) +{ + return a / b; +} + +unsigned int +test01 (unsigned int a, unsigned b) +{ + return a / b; +} + +int +main (int argc, char** argv) +{ + return test00 (argc, 123) + test01 (argc, 123); +} diff --git a/gcc/testsuite/gcc.target/sh/pr49880-4.c b/gcc/testsuite/gcc.target/sh/pr49880-4.c new file mode 100644 index 00000000000..998a8b69fdd --- /dev/null +++ b/gcc/testsuite/gcc.target/sh/pr49880-4.c @@ -0,0 +1,19 @@ +/* Check that the option -mdiv=call-fp does not produce calls to the + library function that uses FPU to implement integer division if FPU insns + are not supported or are disabled. */ +/* { dg-do compile { target "sh*-*-*" } } */ +/* { dg-options "-mdiv=call-fp" } */ +/* { dg-skip-if "" { "sh*-*-*" } { "*"} { "-m1" "-m2" "-m3" "-m4al" "*nofpu" "-m4-340*" "-m4-400*" "-m4-500*" } } */ +/* { dg-final { scan-assembler-not "sdivsi3_i4\n|udivsi3_i4\n" } } */ + +int +test00 (int a, int b) +{ + return a / b; +} + +unsigned int +test01 (unsigned int a, unsigned b) +{ + return a / b; +} diff --git a/gcc/testsuite/gcc.target/sh/pr49880-5.c b/gcc/testsuite/gcc.target/sh/pr49880-5.c new file mode 100644 index 00000000000..09e99a85f63 --- /dev/null +++ b/gcc/testsuite/gcc.target/sh/pr49880-5.c @@ -0,0 +1,19 @@ +/* Check that the option -mdiv=call-fp results in the corresponding library + function calls on targets that have a double precision FPU. */ +/* { dg-do compile { target "sh*-*-*" } } */ +/* { dg-options "-mdiv=call-fp" } */ +/* { dg-skip-if "" { "sh*-*-*" } { "*"} { "-m2a" "-m4" "-m4a" "*single-only" } } */ +/* { dg-final { scan-assembler "sdivsi3_i4\n" } } */ +/* { dg-final { scan-assembler "udivsi3_i4\n" } } */ + +int +test00 (int a, int b) +{ + return a / b; +} + +unsigned int +test01 (unsigned int a, unsigned b) +{ + return a / b; +} diff --git a/gcc/testsuite/gfortran.dg/do_1.f90 b/gcc/testsuite/gfortran.dg/do_1.f90 index 8ed0f7fb6c2..171275af3f2 100644 --- a/gcc/testsuite/gfortran.dg/do_1.f90 +++ b/gcc/testsuite/gfortran.dg/do_1.f90 @@ -1,5 +1,4 @@ -! { dg-do run { xfail *-*-* } } -! XFAIL is tracked in PR 54932 +! { dg-do run } ! Program to check corner cases for DO statements. program do_1 implicit none diff --git a/gcc/testsuite/gfortran.dg/eof_5.f90 b/gcc/testsuite/gfortran.dg/eof_5.f90 new file mode 100644 index 00000000000..88671ba2374 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/eof_5.f90 @@ -0,0 +1,21 @@ +! { dg-do run } +! +! PR fortran/56696 +! +! Contributed by Keith Refson +! + +program iotest + character(len=258) :: inp = ' 1.0 1.0 1.0' + character(len=7) :: inp2 = '1 2 3 4' + integer :: ios + real :: a1, a2, a3, a4 + + read(inp2,*,iostat=ios) a1, a2, a3, a4 + if (ios /= 0) call abort () + + read(inp,*,iostat=ios) a1, a2, a3, a4 + if (ios == 0) call abort () +! write(*,*) 'IOSTAT=',ios +end program iotest + diff --git a/gcc/testsuite/gfortran.dg/namelist_77.f90 b/gcc/testsuite/gfortran.dg/namelist_77.f90 new file mode 100644 index 00000000000..5cbfe3aad65 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/namelist_77.f90 @@ -0,0 +1,49 @@ +! { dg-do run } +! +! PR libfortran/51825 - Fortran runtime error: Cannot match namelist object name +! Test case derived from PR. + +module local_mod + + type mytype1 + integer :: int1 + end type + + type mytype2 + integer :: n_x + integer :: n_px + end type + + type beam_init_struct + character(16) :: chars(1) = '' + type (mytype1) dummy + type (mytype2) grid(1) + end type + +end module + +program error_namelist + + use local_mod + + implicit none + + type (beam_init_struct) beam_init + + namelist / error_params / beam_init + + open (10, status='scratch') + write (10, '(a)') "&error_params" + write (10, '(a)') " beam_init%chars(1)='JUNK'" + write (10, '(a)') " beam_init%grid(1)%n_x=3" + write (10, '(a)') " beam_init%grid(1)%n_px=2" + write (10, '(a)') "/" + rewind(10) + read(10, nml=error_params) + close (10) + + if (beam_init%chars(1) /= 'JUNK') call abort + if (beam_init%grid(1)%n_x /= 3) call abort + if (beam_init%grid(1)%n_px /= 2) call abort + +end program diff --git a/gcc/testsuite/gfortran.dg/namelist_78.f90 b/gcc/testsuite/gfortran.dg/namelist_78.f90 new file mode 100644 index 00000000000..d4e29ab8228 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/namelist_78.f90 @@ -0,0 +1,34 @@ +! { dg-do run } +! +! PR libfortran/51825 +! Test case regarding namelist problems with derived types + +program namelist + + type d1 + integer :: j = 0 + end type d1 + + type d2 + type(d1) k + end type d2 + + type d3 + type(d2) d(2) + end type d3 + + type(d3) der + namelist /nmlst/ der + + open (10, status='scratch') + write (10, '(a)') "&NMLST" + write (10, '(a)') " DER%D(1)%K%J = 1," + write (10, '(a)') " DER%D(2)%K%J = 2," + write (10, '(a)') "/" + rewind(10) + read(10, nml=nmlst) + close (10) + + if (der%d(1)%k%j /= 1) call abort + if (der%d(2)%k%j /= 2) call abort +end program namelist diff --git a/gcc/testsuite/gfortran.dg/open_negative_unit_1.f90 b/gcc/testsuite/gfortran.dg/open_negative_unit_1.f90 new file mode 100644 index 00000000000..6446436c885 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/open_negative_unit_1.f90 @@ -0,0 +1,21 @@ +! { dg-do run } +! PR48618 - Negative unit number in OPEN(...) is sometimes allowed +! +! Test originally from Janne Blomqvist in PR: +! http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48618 + +program nutest + implicit none + integer id, ios + + open(newunit=id, file="foo.txt", iostat=ios) + if (ios /= 0) call abort + + open(id, file="bar.txt", iostat=ios) + if (ios /= 0) call abort + + close(id, status="delete") + + open(-10, file="foo.txt", iostat=ios) + if (ios == 0) call abort +end program nutest diff --git a/gcc/testsuite/gfortran.dg/transfer_intrinsic_5.f90 b/gcc/testsuite/gfortran.dg/transfer_intrinsic_5.f90 new file mode 100644 index 00000000000..47be585a78a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/transfer_intrinsic_5.f90 @@ -0,0 +1,50 @@ +! { dg-do run } +! +! PR fortran/56615 +! +! Contributed by Harald Anlauf +! +! +program gfcbug + implicit none + integer, parameter :: n = 8 + integer :: i + character(len=1), dimension(n) :: a, b + character(len=n) :: s, t + character(len=n/2) :: u + + do i = 1, n + a(i) = achar (i-1 + iachar("a")) + end do +! print *, "# Forward:" +! print *, "a=", a + s = transfer (a, s) +! print *, "s=", s + call cmp (a, s) +! print *, " stride = +2:" + do i = 1, n/2 + u(i:i) = a(2*i-1) + end do +! print *, "u=", u + call cmp (a(1:n:2), u) +! print * +! print *, "# Backward:" + b = a(n:1:-1) +! print *, "b=", b + t = transfer (b, t) +! print *, "t=", t + call cmp (b, t) +! print *, " stride = -1:" + call cmp (a(n:1:-1), t) +contains + subroutine cmp (b, s) + character(len=1), dimension(:), intent(in) :: b + character(len=*), intent(in) :: s + character(len=size(b)) :: c + c = transfer (b, c) + if (c /= s) then + print *, "c=", c, " ", merge (" ok","BUG!", c == s) + call abort () + end if + end subroutine cmp +end program gfcbug diff --git a/gcc/toplev.c b/gcc/toplev.c index 071f1bdc3af..ad423917649 100644 --- a/gcc/toplev.c +++ b/gcc/toplev.c @@ -1951,7 +1951,7 @@ toplev_main (int argc, char **argv) if (!exit_after_options) do_compile (); - if (warningcount || errorcount) + if (warningcount || errorcount || werrorcount) print_ignored_options (); diagnostic_finish (global_dc); @@ -1960,7 +1960,7 @@ toplev_main (int argc, char **argv) finalize_plugins (); location_adhoc_data_fini (line_table); - if (seen_error ()) + if (seen_error () || werrorcount) return (FATAL_EXIT_CODE); return (SUCCESS_EXIT_CODE); diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index e590864b3d0..dce08588798 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -4521,6 +4521,24 @@ verify_location (pointer_set_t *blocks, location_t loc) return false; } +/* Called via walk_tree. Verify that expressions have no blocks. */ + +static tree +verify_expr_no_block (tree *tp, int *walk_subtrees, void *) +{ + if (!EXPR_P (*tp)) + { + *walk_subtrees = false; + return NULL; + } + + location_t loc = EXPR_LOCATION (*tp); + if (LOCATION_BLOCK (loc) != NULL) + return *tp; + + return NULL; +} + /* Called via walk_tree. Verify locations of expressions. */ static tree @@ -4529,10 +4547,20 @@ verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data) struct pointer_set_t *blocks = (struct pointer_set_t *) data; if (TREE_CODE (*tp) == VAR_DECL - && DECL_DEBUG_EXPR_IS_FROM (*tp)) + && DECL_HAS_DEBUG_EXPR_P (*tp)) { tree t = DECL_DEBUG_EXPR (*tp); - tree addr = walk_tree (&t, verify_expr_location_1, blocks, NULL); + tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL); + if (addr) + return addr; + } + if ((TREE_CODE (*tp) == VAR_DECL + || TREE_CODE (*tp) == PARM_DECL + || TREE_CODE (*tp) == RESULT_DECL) + && DECL_HAS_VALUE_EXPR_P (*tp)) + { + tree t = DECL_VALUE_EXPR (*tp); + tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL); if (addr) return addr; } diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c index da335c7c020..cd8f53b7b32 100644 --- a/gcc/tree-complex.c +++ b/gcc/tree-complex.c @@ -428,7 +428,7 @@ create_one_component_var (tree type, tree orig, const char *prefix, DECL_NAME (r) = get_identifier (ACONCAT ((name, suffix, NULL))); SET_DECL_DEBUG_EXPR (r, build1 (code, type, orig)); - DECL_DEBUG_EXPR_IS_FROM (r) = 1; + DECL_HAS_DEBUG_EXPR_P (r) = 1; DECL_IGNORED_P (r) = 0; TREE_NO_WARNING (r) = TREE_NO_WARNING (orig); } 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-diagnostic.c b/gcc/tree-diagnostic.c index 08866a46f17..087cf6acb71 100644 --- a/gcc/tree-diagnostic.c +++ b/gcc/tree-diagnostic.c @@ -268,7 +268,7 @@ default_tree_printer (pretty_printer *pp, text_info *text, const char *spec, case 'D': t = va_arg (*text->args_ptr, tree); - if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t)) + if (TREE_CODE (t) == VAR_DECL && DECL_HAS_DEBUG_EXPR_P (t)) t = DECL_DEBUG_EXPR (t); break; diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index 5121765fd35..a41dd5aeb82 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -1092,22 +1092,22 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data) } else if (TREE_CODE (*tp) == MEM_REF) { - /* We need to re-canonicalize MEM_REFs from inline substitutions - that can happen when a pointer argument is an ADDR_EXPR. */ - tree decl = TREE_OPERAND (*tp, 0); - tree *n; + tree ptr = TREE_OPERAND (*tp, 0); + tree type = remap_type (TREE_TYPE (*tp), id); + tree old = *tp; - n = (tree *) pointer_map_contains (id->decl_map, decl); - if (n) - { - tree old = *tp; - *tp = fold_build2 (MEM_REF, TREE_TYPE (*tp), - unshare_expr (*n), TREE_OPERAND (*tp, 1)); - TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); - TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old); - *walk_subtrees = 0; - return NULL; - } + /* We need to re-canonicalize MEM_REFs from inline substitutions + that can happen when a pointer argument is an ADDR_EXPR. + Recurse here manually to allow that. */ + walk_tree (&ptr, copy_tree_body_r, data, NULL); + *tp = fold_build2 (MEM_REF, type, + ptr, TREE_OPERAND (*tp, 1)); + TREE_THIS_NOTRAP (*tp) = TREE_THIS_NOTRAP (old); + TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); + TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old); + TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old); + *walk_subtrees = 0; + return NULL; } /* Here is the "usual case". Copy this tree node, and then @@ -3762,7 +3762,7 @@ add_local_variables (struct function *callee, struct function *caller, /* Remap debug-expressions. */ if (TREE_CODE (new_var) == VAR_DECL - && DECL_DEBUG_EXPR_IS_FROM (new_var) + && DECL_HAS_DEBUG_EXPR_P (var) && new_var != var) { tree tem = DECL_DEBUG_EXPR (var); @@ -3772,6 +3772,7 @@ add_local_variables (struct function *callee, struct function *caller, id->remapping_type_depth--; id->regimplify = old_regimplify; SET_DECL_DEBUG_EXPR (new_var, tem); + DECL_HAS_DEBUG_EXPR_P (new_var) = 1; } add_local_decl (caller, new_var); } diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h index 0c83921f7d2..0942ad7793f 100644 --- a/gcc/tree-pass.h +++ b/gcc/tree-pass.h @@ -148,6 +148,7 @@ struct simple_ipa_opt_pass #define PROP_cfglayout (1 << 9) /* cfglayout mode on RTL */ #define PROP_gimple_lcx (1 << 10) /* lowered complex */ #define PROP_loops (1 << 11) /* preserve loop structures */ +#define PROP_gimple_lvec (1 << 12) /* lowered vector */ #define PROP_trees \ (PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh | PROP_gimple_lomp) diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 8adc895f128..20f725dba47 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -1987,7 +1987,7 @@ create_access_replacement (struct access *access) if (!fail) { SET_DECL_DEBUG_EXPR (repl, debug_expr); - DECL_DEBUG_EXPR_IS_FROM (repl) = 1; + DECL_HAS_DEBUG_EXPR_P (repl) = 1; } if (access->grp_no_warning) TREE_NO_WARNING (repl) = 1; 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-dom.c b/gcc/tree-ssa-dom.c index f48e4e7fe95..dc4a19d6e48 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -1199,6 +1199,33 @@ record_equivalences_from_incoming_edge (basic_block bb) if (lhs) record_equality (lhs, rhs); + /* If LHS is an SSA_NAME and RHS is a constant and LHS was set + via a widening type conversion, then we may be able to record + additional equivalences. */ + if (lhs + && TREE_CODE (lhs) == SSA_NAME + && is_gimple_constant (rhs)) + { + gimple defstmt = SSA_NAME_DEF_STMT (lhs); + + if (defstmt + && is_gimple_assign (defstmt) + && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (defstmt))) + { + tree old_rhs = gimple_assign_rhs1 (defstmt); + tree newval = fold_convert (TREE_TYPE (old_rhs), rhs); + + /* If this was a widening conversion and if RHS is converted + to the type of OLD_RHS and has the same value, then we + can record an equivalence between OLD_RHS and the + converted representation of RHS. */ + if ((TYPE_PRECISION (TREE_TYPE (lhs)) + > TYPE_PRECISION (TREE_TYPE (old_rhs))) + && operand_equal_p (rhs, newval, 0)) + record_equality (old_rhs, newval); + } + } + for (i = 0; edge_info->cond_equivalences.iterate (i, &eq); ++i) record_cond (eq); } diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c index c918d77e023..3f4b41e2770 100644 --- a/gcc/tree-ssa-live.c +++ b/gcc/tree-ssa-live.c @@ -642,11 +642,6 @@ clear_unused_block_pointer_1 (tree *tp, int *, void *) if (EXPR_P (*tp) && TREE_BLOCK (*tp) && !TREE_USED (TREE_BLOCK (*tp))) TREE_SET_BLOCK (*tp, NULL); - if (TREE_CODE (*tp) == VAR_DECL && DECL_DEBUG_EXPR_IS_FROM (*tp)) - { - tree debug_expr = DECL_DEBUG_EXPR (*tp); - walk_tree (&debug_expr, clear_unused_block_pointer_1, NULL, NULL); - } return NULL_TREE; } @@ -658,15 +653,6 @@ clear_unused_block_pointer (void) { basic_block bb; gimple_stmt_iterator gsi; - tree t; - unsigned i; - - FOR_EACH_LOCAL_DECL (cfun, i, t) - if (TREE_CODE (t) == VAR_DECL && DECL_DEBUG_EXPR_IS_FROM (t)) - { - tree debug_expr = DECL_DEBUG_EXPR (t); - walk_tree (&debug_expr, clear_unused_block_pointer_1, NULL, NULL); - } FOR_EACH_BB (bb) for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c index 99226a67ae7..7ee00d6f585 100644 --- a/gcc/tree-ssa-loop-im.c +++ b/gcc/tree-ssa-loop-im.c @@ -58,15 +58,6 @@ along with GCC; see the file COPYING3. If not see something; } */ -/* A type for the list of statements that have to be moved in order to be able - to hoist an invariant computation. */ - -struct depend -{ - gimple stmt; - struct depend *next; -}; - /* The auxiliary data kept for each statement. */ struct lim_aux_data @@ -85,11 +76,11 @@ struct lim_aux_data unsigned cost; /* Cost of the computation performed by the statement. */ - struct depend *depends; /* List of statements that must be also hoisted - out of the loop when this statement is - hoisted; i.e. those that define the operands - of the statement and are inside of the - MAX_LOOP loop. */ + vec<gimple> depends; /* Vector of statements that must be also + hoisted out of the loop when this statement + is hoisted; i.e. those that define the + operands of the statement and are inside of + the MAX_LOOP loop. */ }; /* Maps statements to their lim_aux_data. */ @@ -105,45 +96,42 @@ typedef struct mem_ref_loc } *mem_ref_loc_p; -/* The list of memory reference locations in a loop. */ - -typedef struct mem_ref_locs -{ - vec<mem_ref_loc_p> locs; -} *mem_ref_locs_p; - - /* Description of a memory reference. */ 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. */ - bitmap stored; /* The set of loops in that this memory location + + /* The memory access itself and associated caching of alias-oracle + query meta-data. */ + ao_ref mem; + + bitmap_head stored; /* The set of loops in that this memory location is stored to. */ - vec<mem_ref_locs_p> accesses_in_loop; + vec<vec<mem_ref_loc> > accesses_in_loop; /* The locations of the accesses. Vector indexed by the loop number. */ /* The following sets are computed on demand. We keep both set and its complement, so that we know whether the information was already computed or not. */ - bitmap indep_loop; /* The set of loops in that the memory + bitmap_head indep_loop; /* The set of loops in that the memory reference is independent, meaning: If it is stored in the loop, this store is independent on all other loads and stores. If it is only loaded, then it is independent on all stores in the loop. */ - bitmap dep_loop; /* The complement of INDEP_LOOP. */ - - bitmap indep_ref; /* The set of memory references on that - this reference is independent. */ - bitmap dep_ref; /* The complement of INDEP_REF. */ + bitmap_head dep_loop; /* The complement of INDEP_LOOP. */ } *mem_ref_p; +/* We use two bits per loop in the ref->{in,}dep_loop bitmaps, the first + to record (in)dependence against stores in the loop and its subloops, the + second to record (in)dependence against all references in the loop + and its subloops. */ +#define LOOP_DEP_BIT(loopnum, storedp) (2 * (loopnum) + (storedp ? 1 : 0)) /* Mem_ref hashtable helpers. */ @@ -169,7 +157,7 @@ mem_ref_hasher::hash (const value_type *mem) inline bool mem_ref_hasher::equal (const value_type *mem1, const compare_type *obj2) { - return operand_equal_p (mem1->mem, obj2, 0); + return operand_equal_p (mem1->mem.ref, (const_tree) obj2, 0); } @@ -184,15 +172,13 @@ static struct vec<mem_ref_p> refs_list; /* The set of memory references accessed in each loop. */ - vec<bitmap> refs_in_loop; + vec<bitmap_head> refs_in_loop; - /* The set of memory references accessed in each loop, including - subloops. */ - vec<bitmap> all_refs_in_loop; + /* The set of memory references stored in each loop. */ + vec<bitmap_head> refs_stored_in_loop; - /* The set of memory references stored in each loop, including - subloops. */ - vec<bitmap> all_refs_stored_in_loop; + /* The set of memory references stored in each loop, including subloops . */ + vec<bitmap_head> all_refs_stored_in_loop; /* Cache for expanding memory addresses. */ struct pointer_map_t *ttae_cache; @@ -211,8 +197,11 @@ static bool ref_indep_loop_p (struct loop *, mem_ref_p); #define ALWAYS_EXECUTED_IN(BB) ((struct loop *) (BB)->aux) #define SET_ALWAYS_EXECUTED_IN(BB, VAL) ((BB)->aux = (void *) (VAL)) +/* ID of the shared unanalyzable mem. */ +#define UNANALYZABLE_MEM_ID 0 + /* Whether the reference was analyzable. */ -#define MEM_ANALYZABLE(REF) ((REF)->mem != error_mark_node) +#define MEM_ANALYZABLE(REF) ((REF)->id != UNANALYZABLE_MEM_ID) static struct lim_aux_data * init_lim_data (gimple stmt) @@ -238,13 +227,7 @@ get_lim_data (gimple stmt) static void free_lim_aux_data (struct lim_aux_data *data) { - struct depend *dep, *next; - - for (dep = data->depends; dep; dep = next) - { - next = dep->next; - free (dep); - } + data->depends.release(); free (data); } @@ -509,7 +492,6 @@ add_dependency (tree def, struct lim_aux_data *data, struct loop *loop, gimple def_stmt = SSA_NAME_DEF_STMT (def); basic_block def_bb = gimple_bb (def_stmt); struct loop *max_loop; - struct depend *dep; struct lim_aux_data *def_data; if (!def_bb) @@ -534,10 +516,7 @@ add_dependency (tree def, struct lim_aux_data *data, struct loop *loop, && def_bb->loop_father == loop) data->cost += def_data->cost; - dep = XNEW (struct depend); - dep->stmt = def_stmt; - dep->next = data->depends; - data->depends = dep; + data->depends.safe_push (def_stmt); return true; } @@ -631,13 +610,13 @@ outermost_indep_loop (struct loop *outer, struct loop *loop, mem_ref_p ref) { struct loop *aloop; - if (bitmap_bit_p (ref->stored, loop->num)) + if (bitmap_bit_p (&ref->stored, loop->num)) return NULL; for (aloop = outer; aloop != loop; aloop = superloop_at_depth (loop, loop_depth (aloop) + 1)) - if (!bitmap_bit_p (ref->stored, aloop->num) + if (!bitmap_bit_p (&ref->stored, aloop->num) && ref_indep_loop_p (aloop, ref)) return aloop; @@ -900,8 +879,9 @@ static void set_level (gimple stmt, struct loop *orig_loop, struct loop *level) { struct loop *stmt_loop = gimple_bb (stmt)->loop_father; - struct depend *dep; struct lim_aux_data *lim_data; + gimple dep_stmt; + unsigned i; stmt_loop = find_common_loop (orig_loop, stmt_loop); lim_data = get_lim_data (stmt); @@ -915,8 +895,8 @@ set_level (gimple stmt, struct loop *orig_loop, struct loop *level) || flow_loop_nested_p (lim_data->max_loop, level)); lim_data->tgt_loop = level; - for (dep = lim_data->depends; dep; dep = dep->next) - set_level (dep->stmt, orig_loop, level); + FOR_EACH_VEC_ELT (lim_data->depends, i, dep_stmt) + set_level (dep_stmt, orig_loop, level); } /* Determines an outermost loop from that we want to hoist the statement STMT. @@ -1457,33 +1437,16 @@ force_move_till (tree ref, tree *index, void *data) return true; } -/* Releases list of memory reference locations ACCS. */ - -static void -free_mem_ref_locs (mem_ref_locs_p accs) -{ - unsigned i; - mem_ref_loc_p loc; - - if (!accs) - return; - - FOR_EACH_VEC_ELT (accs->locs, i, loc) - free (loc); - accs->locs.release (); - free (accs); -} - /* A function to free the mem_ref object OBJ. */ static void memref_free (struct mem_ref *mem) { unsigned i; - mem_ref_locs_p accs; + vec<mem_ref_loc> *accs; FOR_EACH_VEC_ELT (mem->accesses_in_loop, i, accs) - free_mem_ref_locs (accs); + accs->release (); mem->accesses_in_loop.release (); free (mem); @@ -1496,54 +1459,32 @@ 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); - ref->indep_loop = BITMAP_ALLOC (&lim_bitmap_obstack); - ref->dep_loop = BITMAP_ALLOC (&lim_bitmap_obstack); - ref->indep_ref = BITMAP_ALLOC (&lim_bitmap_obstack); - ref->dep_ref = BITMAP_ALLOC (&lim_bitmap_obstack); + bitmap_initialize (&ref->stored, &lim_bitmap_obstack); + bitmap_initialize (&ref->indep_loop, &lim_bitmap_obstack); + bitmap_initialize (&ref->dep_loop, &lim_bitmap_obstack); ref->accesses_in_loop.create (0); return ref; } -/* Allocates and returns the new list of locations. */ - -static mem_ref_locs_p -mem_ref_locs_alloc (void) -{ - mem_ref_locs_p accs = XNEW (struct mem_ref_locs); - accs->locs.create (0); - return accs; -} - /* Records memory reference location *LOC in LOOP to the memory reference description REF. The reference occurs in statement STMT. */ static void record_mem_ref_loc (mem_ref_p ref, struct loop *loop, gimple stmt, tree *loc) { - mem_ref_loc_p aref = XNEW (struct mem_ref_loc); - mem_ref_locs_p accs; - bitmap ril = memory_accesses.refs_in_loop[loop->num]; + mem_ref_loc aref; if (ref->accesses_in_loop.length () <= (unsigned) loop->num) ref->accesses_in_loop.safe_grow_cleared (loop->num + 1); - accs = ref->accesses_in_loop[loop->num]; - if (!accs) - { - accs = mem_ref_locs_alloc (); - ref->accesses_in_loop[loop->num] = accs; - } - - aref->stmt = stmt; - aref->ref = loc; - accs->locs.safe_push (aref); - bitmap_set_bit (ril, ref->id); + aref.stmt = stmt; + aref.ref = loc; + ref->accesses_in_loop[loop->num].safe_push (aref); } /* Marks reference REF as stored in LOOP. */ @@ -1551,11 +1492,9 @@ record_mem_ref_loc (mem_ref_p ref, struct loop *loop, gimple stmt, tree *loc) static void mark_ref_stored (mem_ref_p ref, struct loop *loop) { - for (; - loop != current_loops->tree_root - && !bitmap_bit_p (ref->stored, loop->num); - loop = loop_outer (loop)) - bitmap_set_bit (ref->stored, loop->num); + while (loop != current_loops->tree_root + && bitmap_set_bit (&ref->stored, loop->num)) + loop = loop_outer (loop); } /* Gathers memory references in statement STMT in LOOP, storing the @@ -1579,163 +1518,131 @@ gather_mem_refs_stmt (struct loop *loop, gimple stmt) mem = simple_mem_ref_in_stmt (stmt, &is_stored); if (!mem) { - id = memory_accesses.refs_list.length (); - ref = mem_ref_alloc (error_mark_node, 0, id); - memory_accesses.refs_list.safe_push (ref); + /* We use the shared mem_ref for all unanalyzable refs. */ + id = UNANALYZABLE_MEM_ID; + ref = memory_accesses.refs_list[id]; if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Unanalyzed memory reference %u: ", id); print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); } - if (gimple_vdef (stmt)) - mark_ref_stored (ref, loop); - record_mem_ref_loc (ref, loop, stmt, mem); - return; - } - - hash = iterative_hash_expr (*mem, 0); - slot = memory_accesses.refs.find_slot_with_hash (*mem, hash, INSERT); - - if (*slot) - { - ref = (mem_ref_p) *slot; - id = ref->id; + is_stored = gimple_vdef (stmt); } else { - id = memory_accesses.refs_list.length (); - ref = mem_ref_alloc (*mem, hash, id); - memory_accesses.refs_list.safe_push (ref); - *slot = ref; - - if (dump_file && (dump_flags & TDF_DETAILS)) + hash = iterative_hash_expr (*mem, 0); + slot = memory_accesses.refs.find_slot_with_hash (*mem, hash, INSERT); + if (*slot) { - fprintf (dump_file, "Memory reference %u: ", id); - print_generic_expr (dump_file, ref->mem, TDF_SLIM); - fprintf (dump_file, "\n"); + ref = (mem_ref_p) *slot; + id = ref->id; } - } + else + { + id = memory_accesses.refs_list.length (); + ref = mem_ref_alloc (*mem, hash, id); + memory_accesses.refs_list.safe_push (ref); + *slot = ref; - if (is_stored) - mark_ref_stored (ref, loop); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Memory reference %u: ", id); + print_generic_expr (dump_file, ref->mem.ref, TDF_SLIM); + fprintf (dump_file, "\n"); + } + } - record_mem_ref_loc (ref, loop, stmt, mem); + record_mem_ref_loc (ref, loop, stmt, mem); + } + bitmap_set_bit (&memory_accesses.refs_in_loop[loop->num], ref->id); + if (is_stored) + { + bitmap_set_bit (&memory_accesses.refs_stored_in_loop[loop->num], ref->id); + mark_ref_stored (ref, loop); + } return; } +static unsigned *bb_loop_postorder; + +/* qsort sort function to sort blocks after their loop fathers postorder. */ + +static int +sort_bbs_in_loop_postorder_cmp (const void *bb1_, const void *bb2_) +{ + basic_block bb1 = *(basic_block *)const_cast<void *>(bb1_); + basic_block bb2 = *(basic_block *)const_cast<void *>(bb2_); + struct loop *loop1 = bb1->loop_father; + struct loop *loop2 = bb2->loop_father; + if (loop1->num == loop2->num) + return 0; + return bb_loop_postorder[loop1->num] < bb_loop_postorder[loop2->num] ? -1 : 1; +} + /* Gathers memory references in loops. */ static void -gather_mem_refs_in_loops (void) +analyze_memory_references (void) { gimple_stmt_iterator bsi; - basic_block bb; - struct loop *loop; + basic_block bb, *bbs; + struct loop *loop, *outer; loop_iterator li; - bitmap lrefs, alrefs, alrefso; + unsigned i, n; + /* Initialize bb_loop_postorder with a mapping from loop->num to + its postorder index. */ + i = 0; + bb_loop_postorder = XNEWVEC (unsigned, number_of_loops ()); + FOR_EACH_LOOP (li, loop, LI_FROM_INNERMOST) + bb_loop_postorder[loop->num] = i++; + /* Collect all basic-blocks in loops and sort them after their + loops postorder. */ + i = 0; + bbs = XNEWVEC (basic_block, n_basic_blocks - NUM_FIXED_BLOCKS); FOR_EACH_BB (bb) + if (bb->loop_father != current_loops->tree_root) + bbs[i++] = bb; + n = i; + qsort (bbs, n, sizeof (basic_block), sort_bbs_in_loop_postorder_cmp); + free (bb_loop_postorder); + + /* Visit blocks in loop postorder and assign mem-ref IDs in that order. + That results in better locality for all the bitmaps. */ + for (i = 0; i < n; ++i) { - loop = bb->loop_father; - if (loop == current_loops->tree_root) - continue; - + basic_block bb = bbs[i]; for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) - gather_mem_refs_stmt (loop, gsi_stmt (bsi)); + gather_mem_refs_stmt (bb->loop_father, gsi_stmt (bsi)); } + free (bbs); + /* Propagate the information about accessed memory references up the loop hierarchy. */ FOR_EACH_LOOP (li, loop, LI_FROM_INNERMOST) { - lrefs = memory_accesses.refs_in_loop[loop->num]; - alrefs = memory_accesses.all_refs_in_loop[loop->num]; - bitmap_ior_into (alrefs, lrefs); - - if (loop_outer (loop) == current_loops->tree_root) + /* Finalize the overall touched references (including subloops). */ + bitmap_ior_into (&memory_accesses.all_refs_stored_in_loop[loop->num], + &memory_accesses.refs_stored_in_loop[loop->num]); + + /* Propagate the information about accessed memory references up + the loop hierarchy. */ + outer = loop_outer (loop); + if (outer == current_loops->tree_root) continue; - alrefso = memory_accesses.all_refs_in_loop[loop_outer (loop)->num]; - bitmap_ior_into (alrefso, alrefs); - } -} - -/* Create a mapping from virtual operands to references that touch them - in LOOP. */ - -static void -create_vop_ref_mapping_loop (struct loop *loop) -{ - bitmap refs = memory_accesses.refs_in_loop[loop->num]; - struct loop *sloop; - bitmap_iterator bi; - unsigned i; - mem_ref_p ref; - - EXECUTE_IF_SET_IN_BITMAP (refs, 0, i, bi) - { - ref = memory_accesses.refs_list[i]; - for (sloop = loop; sloop != current_loops->tree_root; - sloop = loop_outer (sloop)) - if (bitmap_bit_p (ref->stored, loop->num)) - { - bitmap refs_stored - = memory_accesses.all_refs_stored_in_loop[sloop->num]; - bitmap_set_bit (refs_stored, ref->id); - } - } -} - -/* For each non-clobbered virtual operand and each loop, record the memory - references in this loop that touch the operand. */ - -static void -create_vop_ref_mapping (void) -{ - loop_iterator li; - struct loop *loop; - - FOR_EACH_LOOP (li, loop, 0) - { - create_vop_ref_mapping_loop (loop); - } -} - -/* Gathers information about memory accesses in the loops. */ - -static void -analyze_memory_references (void) -{ - unsigned i; - bitmap empty; - - memory_accesses.refs.create (100); - memory_accesses.refs_list.create (0); - memory_accesses.refs_in_loop.create (number_of_loops ()); - memory_accesses.all_refs_in_loop.create (number_of_loops ()); - memory_accesses.all_refs_stored_in_loop.create (number_of_loops ()); - - for (i = 0; i < number_of_loops (); i++) - { - empty = BITMAP_ALLOC (&lim_bitmap_obstack); - memory_accesses.refs_in_loop.quick_push (empty); - empty = BITMAP_ALLOC (&lim_bitmap_obstack); - memory_accesses.all_refs_in_loop.quick_push (empty); - empty = BITMAP_ALLOC (&lim_bitmap_obstack); - memory_accesses.all_refs_stored_in_loop.quick_push (empty); + bitmap_ior_into (&memory_accesses.all_refs_stored_in_loop[outer->num], + &memory_accesses.all_refs_stored_in_loop[loop->num]); } - - memory_accesses.ttae_cache = NULL; - - gather_mem_refs_in_loops (); - create_vop_ref_mapping (); } /* Returns true if MEM1 and MEM2 may alias. TTAE_CACHE is used as a cache in 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 @@ -1744,7 +1651,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 @@ -1752,8 +1659,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); @@ -1765,43 +1672,46 @@ mem_refs_may_alias_p (tree mem1, tree mem2, struct pointer_map_t **ttae_cache) return true; } -/* Rewrites location LOC by TMP_VAR. */ +/* Iterates over all locations of REF in LOOP and its subloops calling + fn.operator() with the location as argument. When that operator + returns true the iteration is stopped and true is returned. + Otherwise false is returned. */ -static void -rewrite_mem_ref_loc (mem_ref_loc_p loc, tree tmp_var) -{ - *loc->ref = tmp_var; - update_stmt (loc->stmt); -} - -/* Adds all locations of REF in LOOP and its subloops to LOCS. */ - -static void -get_all_locs_in_loop (struct loop *loop, mem_ref_p ref, - vec<mem_ref_loc_p> *locs) +template <typename FN> +static bool +for_all_locs_in_loop (struct loop *loop, mem_ref_p ref, FN fn) { - mem_ref_locs_p accs; unsigned i; mem_ref_loc_p loc; - bitmap refs = memory_accesses.all_refs_in_loop[loop->num]; struct loop *subloop; - if (!bitmap_bit_p (refs, ref->id)) - return; - - if (ref->accesses_in_loop.length () - > (unsigned) loop->num) - { - accs = ref->accesses_in_loop[loop->num]; - if (accs) - { - FOR_EACH_VEC_ELT (accs->locs, i, loc) - locs->safe_push (loc); - } - } + if (ref->accesses_in_loop.length () > (unsigned) loop->num) + FOR_EACH_VEC_ELT (ref->accesses_in_loop[loop->num], i, loc) + if (fn (loc)) + return true; for (subloop = loop->inner; subloop != NULL; subloop = subloop->next) - get_all_locs_in_loop (subloop, ref, locs); + if (for_all_locs_in_loop (subloop, ref, fn)) + return true; + + return false; +} + +/* Rewrites location LOC by TMP_VAR. */ + +struct rewrite_mem_ref_loc +{ + rewrite_mem_ref_loc (tree tmp_var_) : tmp_var (tmp_var_) {} + bool operator()(mem_ref_loc_p loc); + tree tmp_var; +}; + +bool +rewrite_mem_ref_loc::operator()(mem_ref_loc_p loc) +{ + *loc->ref = tmp_var; + update_stmt (loc->stmt); + return false; } /* Rewrites all references to REF in LOOP by variable TMP_VAR. */ @@ -1809,14 +1719,7 @@ get_all_locs_in_loop (struct loop *loop, mem_ref_p ref, static void rewrite_mem_refs (struct loop *loop, mem_ref_p ref, tree tmp_var) { - unsigned i; - mem_ref_loc_p loc; - vec<mem_ref_loc_p> locs = vNULL; - - get_all_locs_in_loop (loop, ref, &locs); - FOR_EACH_VEC_ELT (locs, i, loc) - rewrite_mem_ref_loc (loc, tmp_var); - locs.release (); + for_all_locs_in_loop (loop, ref, rewrite_mem_ref_loc (tmp_var)); } /* The name and the length of the currently generated variable @@ -2074,36 +1977,40 @@ execute_sm_if_changed (edge ex, tree mem, tree tmp_var, tree flag) EDGE_SUCC (new_bb, 0)->flags &= ~EDGE_FALLTHRU; } +/* When REF is set on the location, set flag indicating the store. */ + +struct sm_set_flag_if_changed +{ + sm_set_flag_if_changed (tree flag_) : flag (flag_) {} + bool operator()(mem_ref_loc_p loc); + tree flag; +}; + +bool +sm_set_flag_if_changed::operator()(mem_ref_loc_p loc) +{ + /* Only set the flag for writes. */ + if (is_gimple_assign (loc->stmt) + && gimple_assign_lhs_ptr (loc->stmt) == loc->ref) + { + gimple_stmt_iterator gsi = gsi_for_stmt (loc->stmt); + gimple stmt = gimple_build_assign (flag, boolean_true_node); + gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING); + } + return false; +} + /* Helper function for execute_sm. On every location where REF is set, set an appropriate flag indicating the store. */ static tree execute_sm_if_changed_flag_set (struct loop *loop, mem_ref_p ref) { - unsigned i; - 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); - get_all_locs_in_loop (loop, ref, &locs); - FOR_EACH_VEC_ELT (locs, i, loc) - { - gimple_stmt_iterator gsi; - gimple stmt; - - /* Only set the flag for writes. */ - if (is_gimple_assign (loc->stmt) - && gimple_assign_lhs_ptr (loc->stmt) == loc->ref) - { - gsi = gsi_for_stmt (loc->stmt); - stmt = gimple_build_assign (flag, boolean_true_node); - gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING); - } - } - locs.release (); + for_all_locs_in_loop (loop, ref, sm_set_flag_if_changed (flag)); return flag; } @@ -2126,16 +2033,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)) @@ -2153,7 +2060,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; @@ -2173,11 +2080,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 @@ -2198,61 +2105,64 @@ hoist_memory_references (struct loop *loop, bitmap mem_refs, } } -/* Returns true if REF is always accessed in LOOP. If STORED_P is true - make sure REF is always stored to in LOOP. */ +struct ref_always_accessed +{ + ref_always_accessed (struct loop *loop_, tree base_, bool stored_p_) + : loop (loop_), base (base_), stored_p (stored_p_) {} + bool operator()(mem_ref_loc_p loc); + struct loop *loop; + tree base; + bool stored_p; +}; -static bool -ref_always_accessed_p (struct loop *loop, mem_ref_p ref, bool stored_p) +bool +ref_always_accessed::operator()(mem_ref_loc_p loc) { - vec<mem_ref_loc_p> locs = vNULL; - unsigned i; - mem_ref_loc_p loc; - bool ret = false; struct loop *must_exec; - tree base; - base = get_base_address (ref->mem); - if (INDIRECT_REF_P (base) - || TREE_CODE (base) == MEM_REF) - base = TREE_OPERAND (base, 0); + if (!get_lim_data (loc->stmt)) + return false; - get_all_locs_in_loop (loop, ref, &locs); - FOR_EACH_VEC_ELT (locs, i, loc) + /* If we require an always executed store make sure the statement + stores to the reference. */ + if (stored_p) { - if (!get_lim_data (loc->stmt)) - continue; + tree lhs; + if (!gimple_get_lhs (loc->stmt)) + return false; + lhs = get_base_address (gimple_get_lhs (loc->stmt)); + if (!lhs) + return false; + if (INDIRECT_REF_P (lhs) + || TREE_CODE (lhs) == MEM_REF) + lhs = TREE_OPERAND (lhs, 0); + if (lhs != base) + return false; + } - /* If we require an always executed store make sure the statement - stores to the reference. */ - if (stored_p) - { - tree lhs; - if (!gimple_get_lhs (loc->stmt)) - continue; - lhs = get_base_address (gimple_get_lhs (loc->stmt)); - if (!lhs) - continue; - if (INDIRECT_REF_P (lhs) - || TREE_CODE (lhs) == MEM_REF) - lhs = TREE_OPERAND (lhs, 0); - if (lhs != base) - continue; - } + must_exec = get_lim_data (loc->stmt)->always_executed_in; + if (!must_exec) + return false; - must_exec = get_lim_data (loc->stmt)->always_executed_in; - if (!must_exec) - continue; + if (must_exec == loop + || flow_loop_nested_p (must_exec, loop)) + return true; - if (must_exec == loop - || flow_loop_nested_p (must_exec, loop)) - { - ret = true; - break; - } - } - locs.release (); + return false; +} - return ret; +/* Returns true if REF is always accessed in LOOP. If STORED_P is true + make sure REF is always stored to in LOOP. */ + +static bool +ref_always_accessed_p (struct loop *loop, mem_ref_p ref, bool stored_p) +{ + tree base = ao_ref_base (&ref->mem); + if (TREE_CODE (base) == MEM_REF) + base = TREE_OPERAND (base, 0); + + return for_all_locs_in_loop (loop, ref, + ref_always_accessed (loop, base, stored_p)); } /* Returns true if REF1 and REF2 are independent. */ @@ -2260,104 +2170,130 @@ 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; 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; } 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; } } -/* Records the information whether REF is independent in LOOP (according - to INDEP). */ +/* Mark REF dependent on stores or loads (according to STORED_P) in LOOP + and its super-loops. */ static void -record_indep_loop (struct loop *loop, mem_ref_p ref, bool indep) +record_dep_loop (struct loop *loop, mem_ref_p ref, bool stored_p) { - if (indep) - bitmap_set_bit (ref->indep_loop, loop->num); - else - bitmap_set_bit (ref->dep_loop, loop->num); + /* We can propagate dependent-in-loop bits up the loop + hierarchy to all outer loops. */ + while (loop != current_loops->tree_root + && bitmap_set_bit (&ref->dep_loop, LOOP_DEP_BIT (loop->num, stored_p))) + loop = loop_outer (loop); } /* Returns true if REF is independent on all other memory references in LOOP. */ static bool -ref_indep_loop_p_1 (struct loop *loop, mem_ref_p ref) +ref_indep_loop_p_1 (struct loop *loop, mem_ref_p ref, bool stored_p) { bitmap refs_to_check; unsigned i; bitmap_iterator bi; - bool ret = true, stored = bitmap_bit_p (ref->stored, loop->num); mem_ref_p aref; - if (stored) - refs_to_check = memory_accesses.all_refs_in_loop[loop->num]; + if (stored_p) + refs_to_check = &memory_accesses.refs_in_loop[loop->num]; else - refs_to_check = memory_accesses.all_refs_stored_in_loop[loop->num]; + refs_to_check = &memory_accesses.refs_stored_in_loop[loop->num]; + + if (bitmap_bit_p (refs_to_check, UNANALYZABLE_MEM_ID)) + return false; EXECUTE_IF_SET_IN_BITMAP (refs_to_check, 0, i, bi) { aref = memory_accesses.refs_list[i]; - if (!MEM_ANALYZABLE (aref) - || !refs_independent_p (ref, aref)) - { - ret = false; - record_indep_loop (loop, aref, false); - break; - } + if (!refs_independent_p (ref, aref)) + return false; } - return ret; + return true; } /* Returns true if REF is independent on all other memory references in LOOP. Wrapper over ref_indep_loop_p_1, caching its results. */ static bool -ref_indep_loop_p (struct loop *loop, mem_ref_p ref) +ref_indep_loop_p_2 (struct loop *loop, mem_ref_p ref, bool stored_p) { - bool ret; + stored_p |= bitmap_bit_p (&ref->stored, loop->num); - if (bitmap_bit_p (ref->indep_loop, loop->num)) + if (bitmap_bit_p (&ref->indep_loop, LOOP_DEP_BIT (loop->num, stored_p))) return true; - if (bitmap_bit_p (ref->dep_loop, loop->num)) + if (bitmap_bit_p (&ref->dep_loop, LOOP_DEP_BIT (loop->num, stored_p))) return false; - ret = ref_indep_loop_p_1 (loop, ref); + struct loop *inner = loop->inner; + while (inner) + { + if (!ref_indep_loop_p_2 (inner, ref, stored_p)) + return false; + inner = inner->next; + } + + bool indep_p = ref_indep_loop_p_1 (loop, ref, stored_p); if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Querying dependencies of ref %u in loop %d: %s\n", - ref->id, loop->num, ret ? "independent" : "dependent"); + ref->id, loop->num, indep_p ? "independent" : "dependent"); + + /* Record the computed result in the cache. */ + if (indep_p) + { + if (bitmap_set_bit (&ref->indep_loop, LOOP_DEP_BIT (loop->num, stored_p)) + && stored_p) + { + /* If it's independend against all refs then it's independent + against stores, too. */ + bitmap_set_bit (&ref->indep_loop, LOOP_DEP_BIT (loop->num, false)); + } + } + else + { + record_dep_loop (loop, ref, stored_p); + if (!stored_p) + { + /* If it's dependent against stores it's dependent against + all refs, too. */ + record_dep_loop (loop, ref, true); + } + } - record_indep_loop (loop, ref, ret); + return indep_p; +} - return ret; +/* Returns true if REF is independent on all other memory references in + LOOP. */ + +static bool +ref_indep_loop_p (struct loop *loop, mem_ref_p ref) +{ + gcc_checking_assert (MEM_ANALYZABLE (ref)); + + return ref_indep_loop_p_2 (loop, ref, false); } /* Returns true if we can perform store motion of REF from LOOP. */ @@ -2371,26 +2307,22 @@ can_sm_ref_p (struct loop *loop, mem_ref_p ref) if (!MEM_ANALYZABLE (ref)) return false; - /* Unless the reference is stored in the loop, there is nothing to do. */ - if (!bitmap_bit_p (ref->stored, loop->num)) - 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; @@ -2410,7 +2342,7 @@ can_sm_ref_p (struct loop *loop, mem_ref_p ref) static void find_refs_for_sm (struct loop *loop, bitmap sm_executed, bitmap refs_to_sm) { - bitmap refs = memory_accesses.all_refs_in_loop[loop->num]; + bitmap refs = &memory_accesses.all_refs_stored_in_loop[loop->num]; unsigned i; bitmap_iterator bi; mem_ref_p ref; @@ -2450,7 +2382,7 @@ store_motion_loop (struct loop *loop, bitmap sm_executed) { vec<edge> exits = get_loop_exit_edges (loop); struct loop *subloop; - bitmap sm_in_loop = BITMAP_ALLOC (NULL); + bitmap sm_in_loop = BITMAP_ALLOC (&lim_bitmap_obstack); if (loop_suitable_for_sm (loop, exits)) { @@ -2473,7 +2405,7 @@ static void store_motion (void) { struct loop *loop; - bitmap sm_executed = BITMAP_ALLOC (NULL); + bitmap sm_executed = BITMAP_ALLOC (&lim_bitmap_obstack); for (loop = current_loops->tree_root->inner; loop != NULL; loop = loop->next) store_motion_loop (loop, sm_executed); @@ -2488,7 +2420,7 @@ store_motion (void) blocks that contain a nonpure call. */ static void -fill_always_executed_in (struct loop *loop, sbitmap contains_call) +fill_always_executed_in_1 (struct loop *loop, sbitmap contains_call) { basic_block bb = NULL, *bbs, last = NULL; unsigned i; @@ -2547,45 +2479,80 @@ fill_always_executed_in (struct loop *loop, sbitmap contains_call) } for (loop = loop->inner; loop; loop = loop->next) - fill_always_executed_in (loop, contains_call); + fill_always_executed_in_1 (loop, contains_call); } -/* Compute the global information needed by the loop invariant motion pass. */ +/* Fills ALWAYS_EXECUTED_IN information for basic blocks, i.e. + for each such basic block bb records the outermost loop for that execution + of its header implies execution of bb. */ static void -tree_ssa_lim_initialize (void) +fill_always_executed_in (void) { sbitmap contains_call = sbitmap_alloc (last_basic_block); - gimple_stmt_iterator bsi; - struct loop *loop; basic_block bb; - - bitmap_obstack_initialize (&lim_bitmap_obstack); + struct loop *loop; bitmap_clear (contains_call); FOR_EACH_BB (bb) { - for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) + gimple_stmt_iterator gsi; + for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { - if (nonpure_call_p (gsi_stmt (bsi))) + if (nonpure_call_p (gsi_stmt (gsi))) break; } - if (!gsi_end_p (bsi)) + if (!gsi_end_p (gsi)) bitmap_set_bit (contains_call, bb->index); } for (loop = current_loops->tree_root->inner; loop; loop = loop->next) - fill_always_executed_in (loop, contains_call); + fill_always_executed_in_1 (loop, contains_call); sbitmap_free (contains_call); +} + + +/* Compute the global information needed by the loop invariant motion pass. */ + +static void +tree_ssa_lim_initialize (void) +{ + unsigned i; + bitmap_obstack_initialize (&lim_bitmap_obstack); lim_aux_data_map = pointer_map_create (); if (flag_tm) compute_transaction_bits (); alloc_aux_for_edges (0); + + memory_accesses.refs.create (100); + memory_accesses.refs_list.create (100); + /* Allocate a special, unanalyzable mem-ref with ID zero. */ + memory_accesses.refs_list.quick_push + (mem_ref_alloc (error_mark_node, 0, UNANALYZABLE_MEM_ID)); + + memory_accesses.refs_in_loop.create (number_of_loops ()); + memory_accesses.refs_in_loop.quick_grow (number_of_loops ()); + memory_accesses.refs_stored_in_loop.create (number_of_loops ()); + memory_accesses.refs_stored_in_loop.quick_grow (number_of_loops ()); + memory_accesses.all_refs_stored_in_loop.create (number_of_loops ()); + memory_accesses.all_refs_stored_in_loop.quick_grow (number_of_loops ()); + + for (i = 0; i < number_of_loops (); i++) + { + bitmap_initialize (&memory_accesses.refs_in_loop[i], + &lim_bitmap_obstack); + bitmap_initialize (&memory_accesses.refs_stored_in_loop[i], + &lim_bitmap_obstack); + bitmap_initialize (&memory_accesses.all_refs_stored_in_loop[i], + &lim_bitmap_obstack); + } + + memory_accesses.ttae_cache = NULL; } /* Cleans up after the invariant motion pass. */ @@ -2612,7 +2579,7 @@ tree_ssa_lim_finalize (void) memory_accesses.refs_list.release (); memory_accesses.refs_in_loop.release (); - memory_accesses.all_refs_in_loop.release (); + memory_accesses.refs_stored_in_loop.release (); memory_accesses.all_refs_stored_in_loop.release (); if (memory_accesses.ttae_cache) @@ -2632,6 +2599,9 @@ tree_ssa_lim (void) /* Gathers information about memory accesses in the loops. */ analyze_memory_references (); + /* Fills ALWAYS_EXECUTED_IN information for basic blocks. */ + fill_always_executed_in (); + /* For each statement determine the outermost loop in that it is invariant and cost for computing the invariant. */ determine_invariantness (); 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-niter.c b/gcc/tree-ssa-loop-niter.c index ba06b0c6936..bcd4317f390 100644 --- a/gcc/tree-ssa-loop-niter.c +++ b/gcc/tree-ssa-loop-niter.c @@ -37,6 +37,7 @@ along with GCC; see the file COPYING3. If not see #include "flags.h" #include "diagnostic-core.h" #include "tree-inline.h" +#include "tree-pass.h" #define SWAP(X, Y) do { affine_iv *tmp = (X); (X) = (Y); (Y) = tmp; } while (0) @@ -2525,6 +2526,40 @@ record_niter_bound (struct loop *loop, double_int i_bound, bool realistic, loop->nb_iterations_estimate = loop->nb_iterations_upper_bound; } +/* Emit a -Waggressive-loop-optimizations warning if needed. */ + +static void +do_warn_aggressive_loop_optimizations (struct loop *loop, + double_int i_bound, gimple stmt) +{ + /* Don't warn if the loop doesn't have known constant bound. */ + if (!loop->nb_iterations + || TREE_CODE (loop->nb_iterations) != INTEGER_CST + || !warn_aggressive_loop_optimizations + /* To avoid warning multiple times for the same loop, + only start warning when we preserve loops. */ + || (cfun->curr_properties & PROP_loops) == 0 + /* Only warn once per loop. */ + || loop->warned_aggressive_loop_optimizations + /* Only warn if undefined behavior gives us lower estimate than the + known constant bound. */ + || i_bound.ucmp (tree_to_double_int (loop->nb_iterations)) >= 0 + /* And undefined behavior happens unconditionally. */ + || !dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (stmt))) + return; + + edge e = single_exit (loop); + if (e == NULL) + return; + + gimple estmt = last_stmt (e->src); + warning_at (gimple_location (stmt), OPT_Waggressive_loop_optimizations, + "iteration %E invokes undefined behavior", + double_int_to_tree (TREE_TYPE (loop->nb_iterations), i_bound)); + inform (gimple_location (estmt), "containing loop"); + loop->warned_aggressive_loop_optimizations = true; +} + /* Records that AT_STMT is executed at most BOUND + 1 times in LOOP. IS_EXIT is true if the loop is exited immediately after STMT, and this exit is taken at last when the STMT is executed BOUND + 1 times. @@ -2560,8 +2595,12 @@ record_estimate (struct loop *loop, tree bound, double_int i_bound, return; /* If we have a guaranteed upper bound, record it in the appropriate - list. */ - if (upper) + list, unless this is an !is_exit bound (i.e. undefined behavior in + at_stmt) in a loop with known constant number of iterations. */ + if (upper + && (is_exit + || loop->nb_iterations == NULL_TREE + || TREE_CODE (loop->nb_iterations) != INTEGER_CST)) { struct nb_iter_bound *elt = ggc_alloc_nb_iter_bound (); @@ -2591,6 +2630,8 @@ record_estimate (struct loop *loop, tree bound, double_int i_bound, if (i_bound.ult (delta)) return; + if (upper && !is_exit) + do_warn_aggressive_loop_optimizations (loop, i_bound, at_stmt); record_niter_bound (loop, i_bound, realistic, upper); } @@ -3311,6 +3352,11 @@ estimate_numbers_of_iterations_loop (struct loop *loop) /* Force estimate compuation but leave any existing upper bound in place. */ loop->any_estimate = false; + /* Ensure that loop->nb_iterations is computed if possible. If it turns out + to be constant, we avoid undefined behavior implied bounds and instead + diagnose those loops with -Waggressive-loop-optimizations. */ + number_of_latch_executions (loop); + exits = get_loop_exit_edges (loop); likely_exit = single_likely_exit (loop); FOR_EACH_VEC_ELT (exits, i, ex) @@ -3345,6 +3391,17 @@ estimate_numbers_of_iterations_loop (struct loop *loop) bound = gcov_type_to_double_int (nit); record_niter_bound (loop, bound, true, false); } + + /* If we know the exact number of iterations of this loop, try to + not break code with undefined behavior by not recording smaller + maximum number of iterations. */ + if (loop->nb_iterations + && TREE_CODE (loop->nb_iterations) == INTEGER_CST) + { + loop->any_upper_bound = true; + loop->nb_iterations_upper_bound + = tree_to_double_int (loop->nb_iterations); + } } /* Sets NIT to the estimated number of executions of the latch of the 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 2609f668942..07bfdcccb81 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -2715,18 +2715,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); } @@ -3125,25 +3120,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 (); } @@ -3561,8 +3569,13 @@ visit_use (tree use) We can value number 2 calls to the same function with the same vuse and the same operands which are not subsequent the same, because there is no code in the program that can - compare the 2 values. */ - || gimple_vdef (stmt))) + compare the 2 values... */ + || (gimple_vdef (stmt) + /* ... unless the call returns a pointer which does + not alias with anything else. In which case the + information that the values are distinct are encoded + in the IL. */ + && !(gimple_call_return_flags (stmt) & ERF_NOALIAS)))) changed = visit_reference_op_call (lhs, stmt); else changed = defs_to_varying (stmt); diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index 48b4008e5ec..bbb84cfd925 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -268,8 +268,12 @@ struct variable_info /* True if this represents a IPA function info. */ unsigned int is_fn_info : 1; - /* A link to the variable for the next field in this structure. */ - struct variable_info *next; + /* The ID of the variable for the next field in this structure + or zero for the last field in this structure. */ + unsigned next; + + /* The ID of the variable for the first field in this structure. */ + unsigned head; /* Offset of this variable, in bits, from the base variable */ unsigned HOST_WIDE_INT offset; @@ -319,10 +323,20 @@ get_varinfo (unsigned int n) return varmap[n]; } -/* Static IDs for the special variables. */ -enum { nothing_id = 0, anything_id = 1, readonly_id = 2, - escaped_id = 3, nonlocal_id = 4, - storedanything_id = 5, integer_id = 6 }; +/* Return the next variable in the list of sub-variables of VI + or NULL if VI is the last sub-variable. */ + +static inline varinfo_t +vi_next (varinfo_t vi) +{ + return get_varinfo (vi->next); +} + +/* Static IDs for the special variables. Variable ID zero is unused + and used as terminator for the sub-variable chain. */ +enum { nothing_id = 1, anything_id = 2, readonly_id = 3, + escaped_id = 4, nonlocal_id = 5, + storedanything_id = 6, integer_id = 7 }; /* Return a new variable info structure consisting for a variable named NAME, and using constraint graph node NODE. Append it @@ -355,7 +369,8 @@ new_var_info (tree t, const char *name) && DECL_HARD_REGISTER (t))); ret->solution = BITMAP_ALLOC (&pta_obstack); ret->oldsolution = NULL; - ret->next = NULL; + ret->next = 0; + ret->head = ret->id; stats.total_vars++; @@ -387,12 +402,14 @@ get_call_vi (gimple call) vi->fullsize = 2; vi->is_full_var = true; - vi->next = vi2 = new_var_info (NULL_TREE, "CALLCLOBBERED"); + vi2 = new_var_info (NULL_TREE, "CALLCLOBBERED"); vi2->offset = 1; vi2->size = 1; vi2->fullsize = 2; vi2->is_full_var = true; + vi->next = vi2->id; + *slot_p = (void *) vi; return vi; } @@ -422,7 +439,7 @@ lookup_call_clobber_vi (gimple call) if (!uses) return NULL; - return uses->next; + return vi_next (uses); } /* Lookup or create the variable for the call statement CALL representing @@ -440,7 +457,7 @@ get_call_use_vi (gimple call) static varinfo_t ATTRIBUTE_UNUSED get_call_clobber_vi (gimple call) { - return get_call_vi (call)->next; + return vi_next (get_call_vi (call)); } @@ -581,7 +598,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 +612,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; @@ -701,8 +718,10 @@ dump_constraint_graph (FILE *file) /* The next lines print the nodes in the graph together with the complex constraints attached to them. */ - for (i = 0; i < graph->size; i++) + for (i = 1; i < graph->size; i++) { + if (i == FIRST_REF_NODE) + continue; if (find (i) != i) continue; if (i < FIRST_REF_NODE) @@ -726,7 +745,7 @@ dump_constraint_graph (FILE *file) /* Go over the edges. */ fprintf (file, "\n // Edges in the constraint graph:\n"); - for (i = 0; i < graph->size; i++) + for (i = 1; i < graph->size; i++) { unsigned j; bitmap_iterator bi; @@ -881,63 +900,71 @@ constraint_set_union (vec<constraint_t> *to, } } -/* Expands the solution in SET to all sub-fields of variables included. - Union the expanded result into RESULT. */ +/* Expands the solution in SET to all sub-fields of variables included. */ static void -solution_set_expand (bitmap result, bitmap set) +solution_set_expand (bitmap set) { bitmap_iterator bi; - bitmap vars = NULL; unsigned j; - /* In a first pass record all variables we need to add all - sub-fields off. This avoids quadratic behavior. */ + /* In a first pass expand to the head of the variables we need to + add all sub-fields off. This avoids quadratic behavior. */ EXECUTE_IF_SET_IN_BITMAP (set, 0, j, bi) { varinfo_t v = get_varinfo (j); if (v->is_artificial_var || v->is_full_var) continue; - v = lookup_vi_for_tree (v->decl); - if (vars == NULL) - vars = BITMAP_ALLOC (NULL); - bitmap_set_bit (vars, v->id); + bitmap_set_bit (set, v->head); } - /* In the second pass now do the addition to the solution and - to speed up solving add it to the delta as well. */ - if (vars != NULL) + /* In the second pass now expand all head variables with subfields. */ + EXECUTE_IF_SET_IN_BITMAP (set, 0, j, bi) { - EXECUTE_IF_SET_IN_BITMAP (vars, 0, j, bi) - { - varinfo_t v = get_varinfo (j); - for (; v != NULL; v = v->next) - bitmap_set_bit (result, v->id); - } - BITMAP_FREE (vars); + varinfo_t v = get_varinfo (j); + if (v->is_artificial_var + || v->is_full_var + || v->head != j) + continue; + for (v = vi_next (v); v != NULL; v = vi_next (v)) + bitmap_set_bit (set, v->id); } } -/* Take a solution set SET, add OFFSET to each member of the set, and - overwrite SET with the result when done. */ +/* Union solution sets TO and FROM, and add INC to each member of FROM in the + process. */ -static void -solution_set_add (bitmap set, HOST_WIDE_INT offset) +static bool +set_union_with_increment (bitmap to, bitmap from, HOST_WIDE_INT inc) { - bitmap result = BITMAP_ALLOC (&iteration_obstack); - unsigned int i; + bool changed = false; bitmap_iterator bi; + unsigned int i; + + /* If the solution of FROM contains anything it is good enough to transfer + this to TO. */ + if (bitmap_bit_p (from, anything_id)) + return bitmap_set_bit (to, anything_id); + + /* For zero offset simply union the solution into the destination. */ + if (inc == 0) + return bitmap_ior_into (to, from); /* If the offset is unknown we have to expand the solution to all subfields. */ - if (offset == UNKNOWN_OFFSET) + if (inc == UNKNOWN_OFFSET) { - solution_set_expand (set, set); - return; + bitmap tmp = BITMAP_ALLOC (&iteration_obstack); + bitmap_copy (tmp, from); + solution_set_expand (tmp); + changed |= bitmap_ior_into (to, tmp); + BITMAP_FREE (tmp); + return changed; } - EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi) + /* For non-zero offset union the offsetted solution into the destination. */ + EXECUTE_IF_SET_IN_BITMAP (from, 0, i, bi) { varinfo_t vi = get_varinfo (i); @@ -946,54 +973,30 @@ solution_set_add (bitmap set, HOST_WIDE_INT offset) if (vi->is_artificial_var || vi->is_unknown_size_var || vi->is_full_var) - bitmap_set_bit (result, i); + changed |= bitmap_set_bit (to, i); else { - unsigned HOST_WIDE_INT fieldoffset = vi->offset + offset; + unsigned HOST_WIDE_INT fieldoffset = vi->offset + inc; /* If the offset makes the pointer point to before the variable use offset zero for the field lookup. */ - if (offset < 0 + if (inc < 0 && fieldoffset > vi->offset) fieldoffset = 0; - if (offset != 0) - vi = first_or_preceding_vi_for_offset (vi, fieldoffset); + vi = first_or_preceding_vi_for_offset (vi, fieldoffset); - bitmap_set_bit (result, vi->id); + changed |= bitmap_set_bit (to, vi->id); /* If the result is not exactly at fieldoffset include the next field as well. See get_constraint_for_ptr_offset for more rationale. */ if (vi->offset != fieldoffset - && vi->next != NULL) - bitmap_set_bit (result, vi->next->id); + && vi->next != 0) + changed |= bitmap_set_bit (to, vi->next); } } - bitmap_copy (set, result); - BITMAP_FREE (result); -} - -/* Union solution sets TO and FROM, and add INC to each member of FROM in the - process. */ - -static bool -set_union_with_increment (bitmap to, bitmap from, HOST_WIDE_INT inc) -{ - if (inc == 0) - return bitmap_ior_into (to, from); - else - { - bitmap tmp; - bool res; - - tmp = BITMAP_ALLOC (&iteration_obstack); - bitmap_copy (tmp, from); - solution_set_add (tmp, inc); - res = bitmap_ior_into (to, tmp); - BITMAP_FREE (tmp); - return res; - } + return changed; } /* Insert constraint C into the list of complex constraints for graph @@ -1023,7 +1026,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 +1146,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 @@ -1200,7 +1193,7 @@ build_pred_graph (void) graph->address_taken = BITMAP_ALLOC (&predbitmap_obstack); bitmap_clear (graph->direct_nodes); - for (j = 0; j < FIRST_REF_NODE; j++) + for (j = 1; j < FIRST_REF_NODE; j++) { if (!get_varinfo (j)->is_special_var) bitmap_set_bit (graph->direct_nodes, j); @@ -1254,11 +1247,11 @@ build_pred_graph (void) v = get_varinfo (rhsvar); if (!v->is_full_var) { - v = lookup_vi_for_tree (v->decl); + v = get_varinfo (v->head); do { bitmap_clear_bit (graph->direct_nodes, v->id); - v = v->next; + v = vi_next (v); } while (v != NULL); } @@ -1319,7 +1312,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 +1389,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 +1448,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 +1467,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 +1566,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. */ @@ -1596,7 +1581,7 @@ do_sd_constraint (constraint_graph_t graph, constraint_t c, dereferenced at all valid offsets. */ if (roffset == UNKNOWN_OFFSET) { - solution_set_expand (delta, delta); + solution_set_expand (delta); /* No further offset processing is necessary. */ roffset = 0; } @@ -1636,10 +1621,10 @@ do_sd_constraint (constraint_graph_t graph, constraint_t c, /* If the variable is not exactly at the requested offset we have to include the next one. */ if (v->offset == (unsigned HOST_WIDE_INT)fieldoffset - || v->next == NULL) + || v->next == 0) break; - v = v->next; + v = vi_next (v); fieldoffset = v->offset; } while (1); @@ -1668,7 +1653,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. */ @@ -1694,7 +1679,7 @@ do_ds_constraint (constraint_t c, bitmap delta) dereferenced at all valid offsets. */ if (loff == UNKNOWN_OFFSET) { - solution_set_expand (delta, delta); + solution_set_expand (delta); loff = 0; } @@ -1742,10 +1727,10 @@ do_ds_constraint (constraint_t c, bitmap delta) /* If the variable is not exactly at the requested offset we have to include the next one. */ if (v->offset == (unsigned HOST_WIDE_INT)fieldoffset - || v->next == NULL) + || v->next == 0) break; - v = v->next; + v = vi_next (v); fieldoffset = v->offset; } while (1); @@ -1782,17 +1767,14 @@ 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; flag = set_union_with_increment (tmp, solution, c->rhs.offset); if (flag) - { - get_varinfo (c->lhs.var)->solution = tmp; - bitmap_set_bit (changed, c->lhs.var); - } + bitmap_set_bit (changed, c->lhs.var); } } @@ -1998,7 +1980,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]; @@ -2013,14 +1995,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. */ @@ -2033,14 +2012,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. */ @@ -2170,6 +2146,77 @@ 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 = 1; i < graph->size; i++) + { + if (i == FIRST_REF_NODE) + continue; + 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 = 1; 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,18 +2235,26 @@ perform_var_substitution (constraint_graph_t graph) /* Condense the nodes, which means to find SCC's, count incoming predecessors, and unite nodes in SCC's. */ - for (i = 0; i < FIRST_REF_NODE; i++) + for (i = 1; i < FIRST_REF_NODE; i++) 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++) + for (i = 1; i < FIRST_REF_NODE; i++) if (!bitmap_bit_p (si->visited, si->node_mapping[i])) label_visit (graph, si, si->node_mapping[i]); /* Calculate location equivalence labels. */ - for (i = 0; i < FIRST_REF_NODE; i++) + for (i = 1; i < FIRST_REF_NODE; i++) { bitmap pointed_by; bitmap_iterator bi; @@ -2237,7 +2292,7 @@ perform_var_substitution (constraint_graph_t graph) } if (dump_file && (dump_flags & TDF_DETAILS)) - for (i = 0; i < FIRST_REF_NODE; i++) + for (i = 1; i < FIRST_REF_NODE; i++) { unsigned j = si->node_mapping[i]; if (j != i) @@ -2257,7 +2312,7 @@ perform_var_substitution (constraint_graph_t graph) /* Quickly eliminate our non-pointer variables. */ - for (i = 0; i < FIRST_REF_NODE; i++) + for (i = 1; i < FIRST_REF_NODE; i++) { unsigned int node = si->node_mapping[i]; @@ -2307,7 +2362,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) { @@ -2324,7 +2379,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; @@ -2344,7 +2399,7 @@ unite_pointer_equivalences (constraint_graph_t graph) /* Go through the pointer equivalences and unite them to their representative, if they aren't already. */ - for (i = 0; i < FIRST_REF_NODE; i++) + for (i = 1; i < FIRST_REF_NODE; i++) { unsigned int label = graph->pe[i]; if (label) @@ -2404,11 +2459,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) { @@ -2460,7 +2516,6 @@ rewrite_constraints (constraint_graph_t graph, rhsvar = find_equivalent_node (graph, rhsvar, rhslabel); c->lhs.var = lhsvar; c->rhs.var = rhsvar; - } } @@ -2521,7 +2576,7 @@ solve_graph (constraint_graph_t graph) changed = BITMAP_ALLOC (NULL); /* Mark all initial non-collapsed nodes as changed. */ - for (i = 0; i < size; i++) + for (i = 1; i < size; i++) { varinfo_t ivi = get_varinfo (i); if (find (i) == i && !bitmap_empty_p (ivi->solution) @@ -2568,8 +2623,19 @@ solve_graph (constraint_graph_t graph) varinfo_t vi = get_varinfo (i); bool solution_empty; - /* Compute the changed set of solution bits. */ - if (vi->oldsolution) + /* Compute the changed set of solution bits. If anything + is in the solution just propagate that. */ + if (bitmap_bit_p (vi->solution, anything_id)) + { + /* If anything is also in the old solution there is + nothing to do. + ??? But we shouldn't ended up with "changed" set ... */ + if (vi->oldsolution + && bitmap_bit_p (vi->oldsolution, anything_id)) + continue; + bitmap_copy (pts, get_varinfo (find (anything_id))->solution); + } + else if (vi->oldsolution) bitmap_and_compl (pts, vi->solution, vi->oldsolution); else bitmap_copy (pts, vi->solution); @@ -2633,13 +2699,10 @@ solve_graph (constraint_graph_t graph) if (i == eff_escaped_id) flag = bitmap_set_bit (tmp, escaped_id); else - flag = set_union_with_increment (tmp, pts, 0); + flag = bitmap_ior_into (tmp, pts); if (flag) - { - get_varinfo (to)->solution = tmp; - bitmap_set_bit (changed, to); - } + bitmap_set_bit (changed, to); } } } @@ -2817,7 +2880,7 @@ get_constraint_for_ssa_var (tree t, vec<ce_s> *results, bool address_p) if (!address_p && !vi->is_full_var) { - for (; vi; vi = vi->next) + for (; vi; vi = vi_next (vi)) { cexpr.var = vi->id; results->safe_push (cexpr); @@ -2964,7 +3027,7 @@ get_constraint_for_ptr_offset (tree ptr, tree offset, /* If we do not know the offset add all subfields. */ && rhsoffset == UNKNOWN_OFFSET) { - varinfo_t temp = lookup_vi_for_tree (curr->decl); + varinfo_t temp = get_varinfo (curr->head); do { struct constraint_expr c2; @@ -2973,7 +3036,7 @@ get_constraint_for_ptr_offset (tree ptr, tree offset, c2.offset = 0; if (c2.var != c.var) results->safe_push (c2); - temp = temp->next; + temp = vi_next (temp); } while (temp); } @@ -3001,10 +3064,10 @@ get_constraint_for_ptr_offset (tree ptr, tree offset, do not result in the same or a conservative superset solution. */ if (temp->offset != offset - && temp->next != NULL) + && temp->next != 0) { struct constraint_expr c2; - c2.var = temp->next->id; + c2.var = temp->next; c2.type = ADDRESSOF; c2.offset = 0; results->safe_push (c2); @@ -3107,7 +3170,7 @@ get_constraint_for_component_ref (tree t, vec<ce_s> *results, varinfo_t curr; results->pop (); cexpr.offset = 0; - for (curr = get_varinfo (cexpr.var); curr; curr = curr->next) + for (curr = get_varinfo (cexpr.var); curr; curr = vi_next (curr)) { if (ranges_overlap_p (curr->offset, curr->size, bitpos, bitmaxsize)) @@ -3124,8 +3187,8 @@ get_constraint_for_component_ref (tree t, vec<ce_s> *results, if (address_p && results->length () == 0) { curr = get_varinfo (cexpr.var); - while (curr->next != NULL) - curr = curr->next; + while (curr->next != 0) + curr = vi_next (curr); cexpr.var = curr->id; results->safe_push (cexpr); } @@ -3321,7 +3384,7 @@ get_constraint_for_1 (tree t, vec<ce_s> *results, bool address_p, return; vi = get_varinfo (cs.var); - curr = vi->next; + curr = vi_next (vi); if (!vi->is_full_var && curr) { @@ -3330,7 +3393,7 @@ get_constraint_for_1 (tree t, vec<ce_s> *results, bool address_p, size = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (t))); else size = -1; - for (; curr; curr = curr->next) + for (; curr; curr = vi_next (curr)) { if (curr->offset - vi->offset < size) { @@ -4200,6 +4263,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: @@ -5003,7 +5089,7 @@ first_vi_for_offset (varinfo_t start, unsigned HOST_WIDE_INT offset) /* If we cannot reach offset from start, lookup the first field and start from there. */ if (start->offset > offset) - start = lookup_vi_for_tree (start->decl); + start = get_varinfo (start->head); while (start) { @@ -5015,7 +5101,7 @@ first_vi_for_offset (varinfo_t start, unsigned HOST_WIDE_INT offset) && (offset - start->offset) < start->size) return start; - start= start->next; + start = vi_next (start); } return NULL; @@ -5032,7 +5118,7 @@ first_or_preceding_vi_for_offset (varinfo_t start, /* If we cannot reach offset from start, lookup the first field and start from there. */ if (start->offset > offset) - start = lookup_vi_for_tree (start->decl); + start = get_varinfo (start->head); /* We may not find a variable in the field list with the actual offset when when we have glommed a structure to a variable. @@ -5043,7 +5129,7 @@ first_or_preceding_vi_for_offset (varinfo_t start, while (start->next && offset >= start->offset && !((offset - start->offset) < start->size)) - start = start->next; + start = vi_next (start); return start; } @@ -5326,7 +5412,7 @@ create_function_info_for (tree decl, const char *name) clobbervi->is_full_var = true; clobbervi->is_global_var = false; gcc_assert (prev_vi->offset < clobbervi->offset); - prev_vi->next = clobbervi; + prev_vi->next = clobbervi->id; prev_vi = clobbervi; asprintf (&tempname, "%s.use", name); @@ -5340,7 +5426,7 @@ create_function_info_for (tree decl, const char *name) usevi->is_full_var = true; usevi->is_global_var = false; gcc_assert (prev_vi->offset < usevi->offset); - prev_vi->next = usevi; + prev_vi->next = usevi->id; prev_vi = usevi; } @@ -5362,7 +5448,7 @@ create_function_info_for (tree decl, const char *name) chainvi->is_full_var = true; chainvi->is_global_var = false; gcc_assert (prev_vi->offset < chainvi->offset); - prev_vi->next = chainvi; + prev_vi->next = chainvi->id; prev_vi = chainvi; insert_vi_for_tree (fn->static_chain_decl, chainvi); } @@ -5391,7 +5477,7 @@ create_function_info_for (tree decl, const char *name) if (DECL_RESULT (decl)) resultvi->may_have_pointers = true; gcc_assert (prev_vi->offset < resultvi->offset); - prev_vi->next = resultvi; + prev_vi->next = resultvi->id; prev_vi = resultvi; if (DECL_RESULT (decl)) insert_vi_for_tree (DECL_RESULT (decl), resultvi); @@ -5421,7 +5507,7 @@ create_function_info_for (tree decl, const char *name) if (arg) argvi->may_have_pointers = true; gcc_assert (prev_vi->offset < argvi->offset); - prev_vi->next = argvi; + prev_vi->next = argvi->id; prev_vi = argvi; if (arg) { @@ -5452,7 +5538,7 @@ create_function_info_for (tree decl, const char *name) argvi->is_heap_var = true; argvi->fullsize = vi->fullsize; gcc_assert (prev_vi->offset < argvi->offset); - prev_vi->next = argvi; + prev_vi->next = argvi->id; prev_vi = argvi; } @@ -5566,7 +5652,7 @@ create_variable_info_for_1 (tree decl, const char *name) vi->fullsize = TREE_INT_CST_LOW (declsize); for (i = 0, newvi = vi; fieldstack.iterate (i, &fo); - ++i, newvi = newvi->next) + ++i, newvi = vi_next (newvi)) { const char *newname = "NULL"; char *tempname; @@ -5585,7 +5671,11 @@ create_variable_info_for_1 (tree decl, const char *name) newvi->may_have_pointers = fo->may_have_pointers; newvi->only_restrict_pointers = fo->only_restrict_pointers; if (i + 1 < fieldstack.length ()) - newvi->next = new_var_info (decl, name); + { + varinfo_t tem = new_var_info (decl, name); + newvi->next = tem->id; + tem->head = vi->id; + } } fieldstack.release (); @@ -5605,7 +5695,7 @@ create_variable_info_for (tree decl, const char *name) return id; /* Create initial constraints for globals. */ - for (; vi; vi = vi->next) + for (; vi; vi = vi_next (vi)) { if (!vi->may_have_pointers || !vi->is_global_var) @@ -5735,7 +5825,7 @@ intra_create_variable_infos (void) rhsc.type = ADDRESSOF; rhsc.offset = 0; process_constraint (new_constraint (lhsc, rhsc)); - for (; vi; vi = vi->next) + for (; vi; vi = vi_next (vi)) if (vi->may_have_pointers) { if (vi->only_restrict_pointers) @@ -5751,7 +5841,7 @@ intra_create_variable_infos (void) make_constraint_from_global_restrict (p, "PARM_RESTRICT"); else { - for (; p; p = p->next) + for (; p; p = vi_next (p)) { if (p->only_restrict_pointers) make_constraint_from_global_restrict (p, "PARM_RESTRICT"); @@ -5767,7 +5857,7 @@ intra_create_variable_infos (void) { varinfo_t p, result_vi = get_vi_for_tree (DECL_RESULT (cfun->decl)); - for (p = result_vi; p; p = p->next) + for (p = result_vi; p; p = vi_next (p)) make_constraint_from (p, nonlocal_id); } @@ -5776,7 +5866,7 @@ intra_create_variable_infos (void) { varinfo_t p, chain_vi = get_vi_for_tree (cfun->static_chain_decl); - for (p = chain_vi; p; p = p->next) + for (p = chain_vi; p; p = vi_next (p)) make_constraint_from (p, nonlocal_id); } } @@ -6299,7 +6389,7 @@ dump_sa_points_to_info (FILE *outfile) stats.num_implicit_edges); } - for (i = 0; i < varmap.length (); i++) + for (i = 1; i < varmap.length (); i++) { varinfo_t vi = get_varinfo (i); if (!vi->may_have_pointers) @@ -6333,6 +6423,9 @@ init_base_vars (void) varinfo_t var_storedanything; varinfo_t var_integer; + /* Variable ID zero is reserved and should be NULL. */ + varmap.safe_push (NULL); + /* Create the NULL variable, used to represent that a variable points to NULL. */ var_nothing = new_var_info (NULL_TREE, "NULL"); @@ -6352,7 +6445,6 @@ init_base_vars (void) var_anything->is_artificial_var = 1; var_anything->size = ~0; var_anything->offset = 0; - var_anything->next = NULL; var_anything->fullsize = ~0; var_anything->is_special_var = 1; @@ -6379,7 +6471,6 @@ init_base_vars (void) var_readonly->offset = 0; var_readonly->size = ~0; var_readonly->fullsize = ~0; - var_readonly->next = NULL; var_readonly->is_special_var = 1; /* readonly memory points to anything, in order to make deref @@ -6476,7 +6567,6 @@ init_base_vars (void) var_integer->size = ~0; var_integer->fullsize = ~0; var_integer->offset = 0; - var_integer->next = NULL; var_integer->is_special_var = 1; /* INTEGER = ANYTHING, because we don't know where a dereference of @@ -6530,7 +6620,7 @@ remove_preds_and_fake_succs (constraint_graph_t graph) /* Clear the implicit ref and address nodes from the successor lists. */ - for (i = 0; i < FIRST_REF_NODE; i++) + for (i = 1; i < FIRST_REF_NODE; i++) { if (graph->succs[i]) bitmap_clear_range (graph->succs[i], FIRST_REF_NODE, @@ -6538,7 +6628,7 @@ remove_preds_and_fake_succs (constraint_graph_t graph) } /* Free the successor list for the non-ref nodes. */ - for (i = FIRST_REF_NODE; i < graph->size; i++) + for (i = FIRST_REF_NODE + 1; i < graph->size; i++) { if (graph->succs[i]) BITMAP_FREE (graph->succs[i]); @@ -6685,7 +6775,8 @@ compute_points_to_sets (void) /* Mark escaped HEAP variables as global. */ FOR_EACH_VEC_ELT (varmap, i, vi) - if (vi->is_heap_var + if (vi + && vi->is_heap_var && !vi->is_global_var) DECL_EXTERNAL (vi->decl) = vi->is_global_var = pt_solution_includes (&cfun->gimple_df->escaped, vi->decl); diff --git a/gcc/tree-streamer-in.c b/gcc/tree-streamer-in.c index ca2e5e9e35e..b5ead0f9eb7 100644 --- a/gcc/tree-streamer-in.c +++ b/gcc/tree-streamer-in.c @@ -203,7 +203,6 @@ unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr) DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1); DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1); DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1); - DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1); DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1); DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1); DECL_ALIGN (expr) = (unsigned) bp_unpack_var_len_unsigned (bp); @@ -226,7 +225,10 @@ unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr) } if (TREE_CODE (expr) == VAR_DECL) - DECL_NONLOCAL_FRAME (expr) = (unsigned) bp_unpack_value (bp, 1); + { + DECL_HAS_DEBUG_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1); + DECL_NONLOCAL_FRAME (expr) = (unsigned) bp_unpack_value (bp, 1); + } if (TREE_CODE (expr) == RESULT_DECL || TREE_CODE (expr) == PARM_DECL diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c index 0ccd41371d1..2625dd6b42f 100644 --- a/gcc/tree-streamer-out.c +++ b/gcc/tree-streamer-out.c @@ -170,7 +170,6 @@ pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr) bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1); bp_pack_value (bp, DECL_USER_ALIGN (expr), 1); bp_pack_value (bp, DECL_PRESERVE_P (expr), 1); - bp_pack_value (bp, DECL_DEBUG_EXPR_IS_FROM (expr), 1); bp_pack_value (bp, DECL_EXTERNAL (expr), 1); bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1); bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr)); @@ -192,7 +191,10 @@ pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr) } if (TREE_CODE (expr) == VAR_DECL) - bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1); + { + bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1); + bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1); + } if (TREE_CODE (expr) == RESULT_DECL || TREE_CODE (expr) == PARM_DECL diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index 932b41e35e5..b38e96ae0b9 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -154,328 +154,6 @@ vect_get_place_in_interleaving_chain (gimple stmt, gimple first_stmt) } -/* Function vect_insert_into_interleaving_chain. - - Insert DRA into the interleaving chain of DRB according to DRA's INIT. */ - -static void -vect_insert_into_interleaving_chain (struct data_reference *dra, - struct data_reference *drb) -{ - gimple prev, next; - tree next_init; - stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra)); - stmt_vec_info stmtinfo_b = vinfo_for_stmt (DR_STMT (drb)); - - prev = GROUP_FIRST_ELEMENT (stmtinfo_b); - next = GROUP_NEXT_ELEMENT (vinfo_for_stmt (prev)); - while (next) - { - next_init = DR_INIT (STMT_VINFO_DATA_REF (vinfo_for_stmt (next))); - if (tree_int_cst_compare (next_init, DR_INIT (dra)) > 0) - { - /* Insert here. */ - GROUP_NEXT_ELEMENT (vinfo_for_stmt (prev)) = DR_STMT (dra); - GROUP_NEXT_ELEMENT (stmtinfo_a) = next; - return; - } - prev = next; - next = GROUP_NEXT_ELEMENT (vinfo_for_stmt (prev)); - } - - /* We got to the end of the list. Insert here. */ - GROUP_NEXT_ELEMENT (vinfo_for_stmt (prev)) = DR_STMT (dra); - GROUP_NEXT_ELEMENT (stmtinfo_a) = NULL; -} - - -/* Function vect_update_interleaving_chain. - - For two data-refs DRA and DRB that are a part of a chain interleaved data - accesses, update the interleaving chain. DRB's INIT is smaller than DRA's. - - There are four possible cases: - 1. New stmts - both DRA and DRB are not a part of any chain: - FIRST_DR = DRB - NEXT_DR (DRB) = DRA - 2. DRB is a part of a chain and DRA is not: - no need to update FIRST_DR - no need to insert DRB - insert DRA according to init - 3. DRA is a part of a chain and DRB is not: - if (init of FIRST_DR > init of DRB) - FIRST_DR = DRB - NEXT(FIRST_DR) = previous FIRST_DR - else - insert DRB according to its init - 4. both DRA and DRB are in some interleaving chains: - choose the chain with the smallest init of FIRST_DR - insert the nodes of the second chain into the first one. */ - -static void -vect_update_interleaving_chain (struct data_reference *drb, - struct data_reference *dra) -{ - stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra)); - stmt_vec_info stmtinfo_b = vinfo_for_stmt (DR_STMT (drb)); - tree next_init, init_dra_chain, init_drb_chain; - gimple first_a, first_b; - tree node_init; - gimple node, prev, next, first_stmt; - - /* 1. New stmts - both DRA and DRB are not a part of any chain. */ - if (!GROUP_FIRST_ELEMENT (stmtinfo_a) && !GROUP_FIRST_ELEMENT (stmtinfo_b)) - { - GROUP_FIRST_ELEMENT (stmtinfo_a) = DR_STMT (drb); - GROUP_FIRST_ELEMENT (stmtinfo_b) = DR_STMT (drb); - GROUP_NEXT_ELEMENT (stmtinfo_b) = DR_STMT (dra); - return; - } - - /* 2. DRB is a part of a chain and DRA is not. */ - if (!GROUP_FIRST_ELEMENT (stmtinfo_a) && GROUP_FIRST_ELEMENT (stmtinfo_b)) - { - GROUP_FIRST_ELEMENT (stmtinfo_a) = GROUP_FIRST_ELEMENT (stmtinfo_b); - /* Insert DRA into the chain of DRB. */ - vect_insert_into_interleaving_chain (dra, drb); - return; - } - - /* 3. DRA is a part of a chain and DRB is not. */ - if (GROUP_FIRST_ELEMENT (stmtinfo_a) && !GROUP_FIRST_ELEMENT (stmtinfo_b)) - { - gimple old_first_stmt = GROUP_FIRST_ELEMENT (stmtinfo_a); - tree init_old = DR_INIT (STMT_VINFO_DATA_REF (vinfo_for_stmt ( - old_first_stmt))); - gimple tmp; - - if (tree_int_cst_compare (init_old, DR_INIT (drb)) > 0) - { - /* DRB's init is smaller than the init of the stmt previously marked - as the first stmt of the interleaving chain of DRA. Therefore, we - update FIRST_STMT and put DRB in the head of the list. */ - GROUP_FIRST_ELEMENT (stmtinfo_b) = DR_STMT (drb); - GROUP_NEXT_ELEMENT (stmtinfo_b) = old_first_stmt; - - /* Update all the stmts in the list to point to the new FIRST_STMT. */ - tmp = old_first_stmt; - while (tmp) - { - GROUP_FIRST_ELEMENT (vinfo_for_stmt (tmp)) = DR_STMT (drb); - tmp = GROUP_NEXT_ELEMENT (vinfo_for_stmt (tmp)); - } - } - else - { - /* Insert DRB in the list of DRA. */ - vect_insert_into_interleaving_chain (drb, dra); - GROUP_FIRST_ELEMENT (stmtinfo_b) = GROUP_FIRST_ELEMENT (stmtinfo_a); - } - return; - } - - /* 4. both DRA and DRB are in some interleaving chains. */ - first_a = GROUP_FIRST_ELEMENT (stmtinfo_a); - first_b = GROUP_FIRST_ELEMENT (stmtinfo_b); - if (first_a == first_b) - return; - init_dra_chain = DR_INIT (STMT_VINFO_DATA_REF (vinfo_for_stmt (first_a))); - init_drb_chain = DR_INIT (STMT_VINFO_DATA_REF (vinfo_for_stmt (first_b))); - - if (tree_int_cst_compare (init_dra_chain, init_drb_chain) > 0) - { - /* Insert the nodes of DRA chain into the DRB chain. - After inserting a node, continue from this node of the DRB chain (don't - start from the beginning. */ - node = GROUP_FIRST_ELEMENT (stmtinfo_a); - prev = GROUP_FIRST_ELEMENT (stmtinfo_b); - first_stmt = first_b; - } - else - { - /* Insert the nodes of DRB chain into the DRA chain. - After inserting a node, continue from this node of the DRA chain (don't - start from the beginning. */ - node = GROUP_FIRST_ELEMENT (stmtinfo_b); - prev = GROUP_FIRST_ELEMENT (stmtinfo_a); - first_stmt = first_a; - } - - while (node) - { - node_init = DR_INIT (STMT_VINFO_DATA_REF (vinfo_for_stmt (node))); - next = GROUP_NEXT_ELEMENT (vinfo_for_stmt (prev)); - while (next) - { - next_init = DR_INIT (STMT_VINFO_DATA_REF (vinfo_for_stmt (next))); - if (tree_int_cst_compare (next_init, node_init) > 0) - { - /* Insert here. */ - GROUP_NEXT_ELEMENT (vinfo_for_stmt (prev)) = node; - GROUP_NEXT_ELEMENT (vinfo_for_stmt (node)) = next; - prev = node; - break; - } - prev = next; - next = GROUP_NEXT_ELEMENT (vinfo_for_stmt (prev)); - } - if (!next) - { - /* We got to the end of the list. Insert here. */ - GROUP_NEXT_ELEMENT (vinfo_for_stmt (prev)) = node; - GROUP_NEXT_ELEMENT (vinfo_for_stmt (node)) = NULL; - prev = node; - } - GROUP_FIRST_ELEMENT (vinfo_for_stmt (node)) = first_stmt; - node = GROUP_NEXT_ELEMENT (vinfo_for_stmt (node)); - } -} - -/* Check dependence between DRA and DRB for basic block vectorization. - If the accesses share same bases and offsets, we can compare their initial - constant offsets to decide whether they differ or not. In case of a read- - write dependence we check that the load is before the store to ensure that - vectorization will not change the order of the accesses. */ - -static bool -vect_drs_dependent_in_basic_block (struct data_reference *dra, - struct data_reference *drb) -{ - HOST_WIDE_INT type_size_a, type_size_b, init_a, init_b; - gimple earlier_stmt; - - /* We only call this function for pairs of loads and stores, but we verify - it here. */ - if (DR_IS_READ (dra) == DR_IS_READ (drb)) - { - if (DR_IS_READ (dra)) - return false; - else - return true; - } - - /* Check that the data-refs have same bases and offsets. If not, we can't - determine if they are dependent. */ - if (!operand_equal_p (DR_BASE_ADDRESS (dra), DR_BASE_ADDRESS (drb), 0) - || !dr_equal_offsets_p (dra, drb)) - return true; - - /* Check the types. */ - type_size_a = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dra)))); - type_size_b = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (drb)))); - - if (type_size_a != type_size_b - || !types_compatible_p (TREE_TYPE (DR_REF (dra)), - TREE_TYPE (DR_REF (drb)))) - return true; - - init_a = TREE_INT_CST_LOW (DR_INIT (dra)); - init_b = TREE_INT_CST_LOW (DR_INIT (drb)); - - /* Two different locations - no dependence. */ - if (init_a != init_b) - return false; - - /* We have a read-write dependence. Check that the load is before the store. - When we vectorize basic blocks, vector load can be only before - corresponding scalar load, and vector store can be only after its - corresponding scalar store. So the order of the acceses is preserved in - case the load is before the store. */ - earlier_stmt = get_earlier_stmt (DR_STMT (dra), DR_STMT (drb)); - if (DR_IS_READ (STMT_VINFO_DATA_REF (vinfo_for_stmt (earlier_stmt)))) - return false; - - return true; -} - - -/* Function vect_check_interleaving. - - Check if DRA and DRB are a part of interleaving. In case they are, insert - DRA and DRB in an interleaving chain. */ - -static bool -vect_check_interleaving (struct data_reference *dra, - struct data_reference *drb) -{ - HOST_WIDE_INT type_size_a, type_size_b, diff_mod_size, step, init_a, init_b; - - /* Check that the data-refs have same first location (except init) and they - are both either store or load (not load and store). */ - if (!operand_equal_p (DR_BASE_ADDRESS (dra), DR_BASE_ADDRESS (drb), 0) - || !dr_equal_offsets_p (dra, drb) - || !tree_int_cst_compare (DR_INIT (dra), DR_INIT (drb)) - || DR_IS_READ (dra) != DR_IS_READ (drb)) - return false; - - /* Check: - 1. data-refs are of the same type - 2. their steps are equal - 3. the step (if greater than zero) is greater than the difference between - data-refs' inits. */ - type_size_a = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dra)))); - type_size_b = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (drb)))); - - if (type_size_a != type_size_b - || tree_int_cst_compare (DR_STEP (dra), DR_STEP (drb)) - || !types_compatible_p (TREE_TYPE (DR_REF (dra)), - TREE_TYPE (DR_REF (drb)))) - return false; - - init_a = TREE_INT_CST_LOW (DR_INIT (dra)); - init_b = TREE_INT_CST_LOW (DR_INIT (drb)); - step = TREE_INT_CST_LOW (DR_STEP (dra)); - - if (init_a > init_b) - { - /* If init_a == init_b + the size of the type * k, we have an interleaving, - and DRB is accessed before DRA. */ - diff_mod_size = (init_a - init_b) % type_size_a; - - if (step && (init_a - init_b) > step) - return false; - - if (diff_mod_size == 0) - { - vect_update_interleaving_chain (drb, dra); - if (dump_enabled_p ()) - { - dump_printf_loc (MSG_NOTE, vect_location, - "Detected interleaving "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (dra)); - dump_printf (MSG_NOTE, " and "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (drb)); - } - return true; - } - } - else - { - /* If init_b == init_a + the size of the type * k, we have an - interleaving, and DRA is accessed before DRB. */ - diff_mod_size = (init_b - init_a) % type_size_a; - - if (step && (init_b - init_a) > step) - return false; - - if (diff_mod_size == 0) - { - vect_update_interleaving_chain (dra, drb); - if (dump_enabled_p ()) - { - dump_printf_loc (MSG_NOTE, vect_location, - "Detected interleaving "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (dra)); - dump_printf (MSG_NOTE, " and "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (drb)); - } - return true; - } - } - - return false; -} - /* Check if data references pointed by DR_I and DR_J are same or belong to same interleaving group. Return FALSE if drs are different, otherwise return TRUE. */ @@ -578,7 +256,7 @@ vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr, loop_vec_info loop_vinfo, int *max_vf) { unsigned int i; - struct loop *loop = NULL; + struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); struct data_reference *dra = DDR_A (ddr); struct data_reference *drb = DDR_B (ddr); stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra)); @@ -586,103 +264,39 @@ vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr, lambda_vector dist_v; unsigned int loop_depth; - /* Don't bother to analyze statements marked as unvectorizable. */ + /* In loop analysis all data references should be vectorizable. */ if (!STMT_VINFO_VECTORIZABLE (stmtinfo_a) || !STMT_VINFO_VECTORIZABLE (stmtinfo_b)) - return false; + gcc_unreachable (); + /* Independent data accesses. */ if (DDR_ARE_DEPENDENT (ddr) == chrec_known) - { - /* Independent data accesses. */ - vect_check_interleaving (dra, drb); - return false; - } - - if (loop_vinfo) - loop = LOOP_VINFO_LOOP (loop_vinfo); + return false; - if ((DR_IS_READ (dra) && DR_IS_READ (drb) && loop_vinfo) || dra == drb) + if (dra == drb + || (DR_IS_READ (dra) && DR_IS_READ (drb))) return false; + /* Unknown data dependence. */ if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know) { - gimple earlier_stmt; - - if (loop_vinfo) - { - if (dump_enabled_p ()) - { - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "versioning for alias required: " - "can't determine dependence between "); - dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, - DR_REF (dra)); - dump_printf (MSG_MISSED_OPTIMIZATION, " and "); - dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, - DR_REF (drb)); - } - - /* Add to list of ddrs that need to be tested at run-time. */ - return !vect_mark_for_runtime_alias_test (ddr, loop_vinfo); - } - - /* When vectorizing a basic block unknown depnedence can still mean - grouped access. */ - if (vect_check_interleaving (dra, drb)) - return false; - - /* Read-read is OK (we need this check here, after checking for - interleaving). */ - if (DR_IS_READ (dra) && DR_IS_READ (drb)) - return false; - if (dump_enabled_p ()) - { - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "can't determine dependence between "); - dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, DR_REF (dra)); - dump_printf (MSG_MISSED_OPTIMIZATION, " and "); - dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, DR_REF (drb)); - } - - /* We do not vectorize basic blocks with write-write dependencies. */ - if (DR_IS_WRITE (dra) && DR_IS_WRITE (drb)) - return true; - - /* Check that it's not a load-after-store dependence. */ - earlier_stmt = get_earlier_stmt (DR_STMT (dra), DR_STMT (drb)); - if (DR_IS_WRITE (STMT_VINFO_DATA_REF (vinfo_for_stmt (earlier_stmt)))) - return true; - - return false; - } - - /* Versioning for alias is not yet supported for basic block SLP, and - dependence distance is unapplicable, hence, in case of known data - dependence, basic block vectorization is impossible for now. */ - if (!loop_vinfo) - { - if (dra != drb && vect_check_interleaving (dra, drb)) - return false; - - if (dump_enabled_p ()) - { - dump_printf_loc (MSG_NOTE, vect_location, - "determined dependence between "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (dra)); - dump_printf (MSG_NOTE, " and "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (drb)); - } - - /* Do not vectorize basic blcoks with write-write dependences. */ - if (DR_IS_WRITE (dra) && DR_IS_WRITE (drb)) - return true; + { + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "versioning for alias required: " + "can't determine dependence between "); + dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, + DR_REF (dra)); + dump_printf (MSG_MISSED_OPTIMIZATION, " and "); + dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, + DR_REF (drb)); + } - /* Check if this dependence is allowed in basic block vectorization. */ - return vect_drs_dependent_in_basic_block (dra, drb); + /* Add to list of ddrs that need to be tested at run-time. */ + return !vect_mark_for_runtime_alias_test (ddr, loop_vinfo); } - /* Loop-based vectorization and known data dependence. */ + /* Known data dependence. */ if (DDR_NUM_DIST_VECTS (ddr) == 0) { if (dump_enabled_p ()) @@ -719,7 +333,7 @@ vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr, } /* For interleaving, mark that there is a read-write dependency if - necessary. We check before that one of the data-refs is store. */ + necessary. We check before that one of the data-refs is store. */ if (DR_IS_READ (dra)) GROUP_READ_WRITE_DEPENDENCE (stmtinfo_a) = true; else @@ -787,22 +401,21 @@ vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr, the maximum vectorization factor the data dependences allow. */ bool -vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo, - bb_vec_info bb_vinfo, int *max_vf) +vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo, int *max_vf) { unsigned int i; - vec<ddr_p> ddrs = vNULL; struct data_dependence_relation *ddr; if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, - "=== vect_analyze_dependences ==="); - if (loop_vinfo) - ddrs = LOOP_VINFO_DDRS (loop_vinfo); - else - ddrs = BB_VINFO_DDRS (bb_vinfo); + "=== vect_analyze_data_ref_dependences ==="); + + if (!compute_all_dependences (LOOP_VINFO_DATAREFS (loop_vinfo), + &LOOP_VINFO_DDRS (loop_vinfo), + LOOP_VINFO_LOOP_NEST (loop_vinfo), true)) + return false; - FOR_EACH_VEC_ELT (ddrs, i, ddr) + FOR_EACH_VEC_ELT (LOOP_VINFO_DDRS (loop_vinfo), i, ddr) if (vect_analyze_data_ref_dependence (ddr, loop_vinfo, max_vf)) return false; @@ -810,6 +423,145 @@ vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo, } +/* Function vect_slp_analyze_data_ref_dependence. + + Return TRUE if there (might) exist a dependence between a memory-reference + DRA and a memory-reference DRB. When versioning for alias may check a + dependence at run-time, return FALSE. Adjust *MAX_VF according to + the data dependence. */ + +static bool +vect_slp_analyze_data_ref_dependence (struct data_dependence_relation *ddr) +{ + struct data_reference *dra = DDR_A (ddr); + struct data_reference *drb = DDR_B (ddr); + + /* We need to check dependences of statements marked as unvectorizable + as well, they still can prohibit vectorization. */ + + /* Independent data accesses. */ + if (DDR_ARE_DEPENDENT (ddr) == chrec_known) + return false; + + if (dra == drb) + return false; + + /* Read-read is OK. */ + if (DR_IS_READ (dra) && DR_IS_READ (drb)) + return false; + + /* Unknown data dependence. */ + if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know) + { + gimple earlier_stmt; + + if (dump_enabled_p ()) + { + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "can't determine dependence between "); + dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, DR_REF (dra)); + dump_printf (MSG_MISSED_OPTIMIZATION, " and "); + dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, DR_REF (drb)); + } + + /* We do not vectorize basic blocks with write-write dependencies. */ + if (DR_IS_WRITE (dra) && DR_IS_WRITE (drb)) + return true; + + /* Check that it's not a load-after-store dependence. */ + earlier_stmt = get_earlier_stmt (DR_STMT (dra), DR_STMT (drb)); + if (DR_IS_WRITE (STMT_VINFO_DATA_REF (vinfo_for_stmt (earlier_stmt)))) + return true; + + return false; + } + + if (dump_enabled_p ()) + { + dump_printf_loc (MSG_NOTE, vect_location, + "determined dependence between "); + dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (dra)); + dump_printf (MSG_NOTE, " and "); + dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (drb)); + } + + /* Do not vectorize basic blocks with write-write dependences. */ + if (DR_IS_WRITE (dra) && DR_IS_WRITE (drb)) + return true; + + /* Check dependence between DRA and DRB for basic block vectorization. + If the accesses share same bases and offsets, we can compare their initial + constant offsets to decide whether they differ or not. In case of a read- + write dependence we check that the load is before the store to ensure that + vectorization will not change the order of the accesses. */ + + HOST_WIDE_INT type_size_a, type_size_b, init_a, init_b; + gimple earlier_stmt; + + /* Check that the data-refs have same bases and offsets. If not, we can't + determine if they are dependent. */ + if (!operand_equal_p (DR_BASE_ADDRESS (dra), DR_BASE_ADDRESS (drb), 0) + || !dr_equal_offsets_p (dra, drb)) + return true; + + /* Check the types. */ + type_size_a = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dra)))); + type_size_b = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (drb)))); + + if (type_size_a != type_size_b + || !types_compatible_p (TREE_TYPE (DR_REF (dra)), + TREE_TYPE (DR_REF (drb)))) + return true; + + init_a = TREE_INT_CST_LOW (DR_INIT (dra)); + init_b = TREE_INT_CST_LOW (DR_INIT (drb)); + + /* Two different locations - no dependence. */ + if (init_a != init_b) + return false; + + /* We have a read-write dependence. Check that the load is before the store. + When we vectorize basic blocks, vector load can be only before + corresponding scalar load, and vector store can be only after its + corresponding scalar store. So the order of the acceses is preserved in + case the load is before the store. */ + earlier_stmt = get_earlier_stmt (DR_STMT (dra), DR_STMT (drb)); + if (DR_IS_READ (STMT_VINFO_DATA_REF (vinfo_for_stmt (earlier_stmt)))) + return false; + + return true; +} + + +/* Function vect_analyze_data_ref_dependences. + + Examine all the data references in the basic-block, and make sure there + do not exist any data dependences between them. Set *MAX_VF according to + the maximum vectorization factor the data dependences allow. */ + +bool +vect_slp_analyze_data_ref_dependences (bb_vec_info bb_vinfo) +{ + struct data_dependence_relation *ddr; + unsigned int i; + + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "=== vect_slp_analyze_data_ref_dependences ==="); + + if (!compute_all_dependences (BB_VINFO_DATAREFS (bb_vinfo), + &BB_VINFO_DDRS (bb_vinfo), + vNULL, true)) + return false; + + FOR_EACH_VEC_ELT (BB_VINFO_DDRS (bb_vinfo), i, ddr) + if (vect_slp_analyze_data_ref_dependence (ddr)) + return false; + + return true; +} + + /* Function vect_compute_data_ref_alignment Compute the misalignment of the data reference DR. @@ -2532,6 +2284,68 @@ vect_analyze_data_ref_access (struct data_reference *dr) return vect_analyze_group_access (dr); } +/* Compare two data-references DRA and DRB to group them into chunks + suitable for grouping. */ + +static int +dr_group_sort_cmp (const void *dra_, const void *drb_) +{ + data_reference_p dra = *(data_reference_p *)const_cast<void *>(dra_); + data_reference_p drb = *(data_reference_p *)const_cast<void *>(drb_); + hashval_t h1, h2; + int cmp; + + /* Stabilize sort. */ + if (dra == drb) + return 0; + + /* Ordering of DRs according to base. */ + if (!operand_equal_p (DR_BASE_ADDRESS (dra), DR_BASE_ADDRESS (drb), 0)) + { + h1 = iterative_hash_expr (DR_BASE_ADDRESS (dra), 0); + h2 = iterative_hash_expr (DR_BASE_ADDRESS (drb), 0); + if (h1 != h2) + return h1 < h2 ? -1 : 1; + } + + /* And according to DR_OFFSET. */ + if (!dr_equal_offsets_p (dra, drb)) + { + h1 = iterative_hash_expr (DR_OFFSET (dra), 0); + h2 = iterative_hash_expr (DR_OFFSET (drb), 0); + if (h1 != h2) + return h1 < h2 ? -1 : 1; + } + + /* Put reads before writes. */ + if (DR_IS_READ (dra) != DR_IS_READ (drb)) + return DR_IS_READ (dra) ? -1 : 1; + + /* Then sort after access size. */ + if (!operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dra))), + TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (drb))), 0)) + { + h1 = iterative_hash_expr (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dra))), 0); + h2 = iterative_hash_expr (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (drb))), 0); + if (h1 != h2) + return h1 < h2 ? -1 : 1; + } + + /* And after step. */ + if (!operand_equal_p (DR_STEP (dra), DR_STEP (drb), 0)) + { + h1 = iterative_hash_expr (DR_STEP (dra), 0); + h2 = iterative_hash_expr (DR_STEP (drb), 0); + if (h1 != h2) + return h1 < h2 ? -1 : 1; + } + + /* Then sort after DR_INIT. In case of identical DRs sort after stmt UID. */ + cmp = tree_int_cst_compare (DR_INIT (dra), DR_INIT (drb)); + if (cmp == 0) + return gimple_uid (DR_STMT (dra)) < gimple_uid (DR_STMT (drb)) ? -1 : 1; + return cmp; +} /* Function vect_analyze_data_ref_accesses. @@ -2558,6 +2372,98 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) else datarefs = BB_VINFO_DATAREFS (bb_vinfo); + if (datarefs.is_empty ()) + return true; + + /* Sort the array of datarefs to make building the interleaving chains + linear. */ + qsort (datarefs.address(), datarefs.length (), + sizeof (data_reference_p), dr_group_sort_cmp); + + /* Build the interleaving chains. */ + for (i = 0; i < datarefs.length () - 1;) + { + data_reference_p dra = datarefs[i]; + stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra)); + stmt_vec_info lastinfo = NULL; + for (i = i + 1; i < datarefs.length (); ++i) + { + data_reference_p drb = datarefs[i]; + stmt_vec_info stmtinfo_b = vinfo_for_stmt (DR_STMT (drb)); + + /* ??? Imperfect sorting (non-compatible types, non-modulo + accesses, same accesses) can lead to a group to be artificially + split here as we don't just skip over those. If it really + matters we can push those to a worklist and re-iterate + over them. The we can just skip ahead to the next DR here. */ + + /* Check that the data-refs have same first location (except init) + and they are both either store or load (not load and store). */ + if (DR_IS_READ (dra) != DR_IS_READ (drb) + || !operand_equal_p (DR_BASE_ADDRESS (dra), + DR_BASE_ADDRESS (drb), 0) + || !dr_equal_offsets_p (dra, drb)) + break; + + /* Check that the data-refs have the same constant size and step. */ + tree sza = TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dra))); + tree szb = TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (drb))); + if (!host_integerp (sza, 1) + || !host_integerp (szb, 1) + || !tree_int_cst_equal (sza, szb) + || !host_integerp (DR_STEP (dra), 0) + || !host_integerp (DR_STEP (drb), 0) + || !tree_int_cst_equal (DR_STEP (dra), DR_STEP (drb))) + break; + + /* Do not place the same access in the interleaving chain twice. */ + if (tree_int_cst_compare (DR_INIT (dra), DR_INIT (drb)) == 0) + break; + + /* Check the types are compatible. + ??? We don't distinguish this during sorting. */ + if (!types_compatible_p (TREE_TYPE (DR_REF (dra)), + TREE_TYPE (DR_REF (drb)))) + break; + + /* Sorting has ensured that DR_INIT (dra) <= DR_INIT (drb). */ + HOST_WIDE_INT init_a = TREE_INT_CST_LOW (DR_INIT (dra)); + HOST_WIDE_INT init_b = TREE_INT_CST_LOW (DR_INIT (drb)); + gcc_assert (init_a < init_b); + + /* If init_b == init_a + the size of the type * k, we have an + interleaving, and DRA is accessed before DRB. */ + HOST_WIDE_INT type_size_a = TREE_INT_CST_LOW (sza); + if ((init_b - init_a) % type_size_a != 0) + break; + + /* The step (if not zero) is greater than the difference between + data-refs' inits. This splits groups into suitable sizes. */ + HOST_WIDE_INT step = TREE_INT_CST_LOW (DR_STEP (dra)); + if (step != 0 && step <= (init_b - init_a)) + break; + + if (dump_enabled_p ()) + { + dump_printf_loc (MSG_NOTE, vect_location, + "Detected interleaving "); + dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (dra)); + dump_printf (MSG_NOTE, " and "); + dump_generic_expr (MSG_NOTE, TDF_SLIM, DR_REF (drb)); + } + + /* Link the found element into the group list. */ + if (!GROUP_FIRST_ELEMENT (stmtinfo_a)) + { + GROUP_FIRST_ELEMENT (stmtinfo_a) = DR_STMT (dra); + lastinfo = stmtinfo_a; + } + GROUP_FIRST_ELEMENT (stmtinfo_b) = DR_STMT (dra); + GROUP_NEXT_ELEMENT (lastinfo) = DR_STMT (drb); + lastinfo = stmtinfo_b; + } + } + FOR_EACH_VEC_ELT (datarefs, i, dr) if (STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (DR_STMT (dr))) && !vect_analyze_data_ref_access (dr)) @@ -2918,7 +2824,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, @@ -2927,13 +2832,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, @@ -2964,17 +2865,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); } @@ -3001,12 +2891,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)) @@ -3047,11 +2931,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; } @@ -3065,11 +2945,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); @@ -3086,11 +2962,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; } @@ -3106,11 +2978,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); @@ -3129,11 +2997,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); @@ -3154,11 +3018,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); @@ -3293,11 +3153,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); @@ -3323,12 +3179,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) { @@ -3346,14 +3197,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 @@ -3373,59 +3217,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 @@ -3449,6 +3241,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; } @@ -3533,19 +3341,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) { @@ -3557,6 +3362,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); @@ -3567,29 +3378,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 */ @@ -3603,34 +3402,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; } @@ -3710,7 +3501,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); @@ -3762,53 +3552,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-generic.c b/gcc/tree-vect-generic.c index b53ccd1c875..dbad6d97598 100644 --- a/gcc/tree-vect-generic.c +++ b/gcc/tree-vect-generic.c @@ -1472,7 +1472,7 @@ expand_vector_operations_1 (gimple_stmt_iterator *gsi) static bool gate_expand_vector_operations_ssa (void) { - return optimize == 0; + return !(cfun->curr_properties & PROP_gimple_lvec); } static unsigned int @@ -1513,7 +1513,7 @@ struct gimple_opt_pass pass_lower_vector = 0, /* static_pass_number */ TV_NONE, /* tv_id */ PROP_cfg, /* properties_required */ - 0, /* properties_provided */ + PROP_gimple_lvec, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ TODO_update_ssa /* todo_flags_finish */ @@ -1536,7 +1536,7 @@ struct gimple_opt_pass pass_lower_vector_ssa = 0, /* static_pass_number */ TV_NONE, /* tv_id */ PROP_cfg, /* properties_required */ - 0, /* properties_provided */ + PROP_gimple_lvec, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ TODO_update_ssa /* todo_flags_finish */ diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c index 559f6e9e997..b0120a9d4de 100644 --- a/gcc/tree-vect-loop-manip.c +++ b/gcc/tree-vect-loop-manip.c @@ -848,9 +848,6 @@ slpeel_can_duplicate_loop_p (const struct loop *loop, const_edge e) gimple orig_cond = get_loop_exit_condition (loop); gimple_stmt_iterator loop_exit_gsi = gsi_last_bb (exit_e->src); - if (need_ssa_update_p (cfun)) - return false; - if (loop->inner /* All loops have an outer scope; the only case loop->outer is NULL is for the function itself. */ @@ -1060,6 +1057,15 @@ slpeel_tree_peel_loop_to_edge (struct loop *loop, if (!slpeel_can_duplicate_loop_p (loop, e)) return NULL; + /* We might have a queued need to update virtual SSA form. As we + delete the update SSA machinery below after doing a regular + incremental SSA update during loop copying make sure we don't + lose that fact. + ??? Needing to update virtual SSA form by renaming is unfortunate + but not all of the vectorizer code inserting new loads / stores + properly assigns virtual operands to those statements. */ + update_ssa (TODO_update_ssa_only_virtuals); + /* If the loop has a virtual PHI, but exit bb doesn't, create a virtual PHI in the exit bb and rename all the uses after the loop. This simplifies the *guard[12] routines, which assume loop closed SSA form for all PHIs @@ -2271,20 +2277,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 +2333,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 +2437,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 68b9a583bb2..c707d76e8af 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -1588,6 +1588,18 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo) return false; } + /* Analyze the access patterns of the data-refs in the loop (consecutive, + complex, etc.). FORNOW: Only handle consecutive access pattern. */ + + ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL); + if (!ok) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "bad data access."); + return false; + } + /* Classify all cross-iteration scalar data-flow cycles. Cross-iteration cycles caused by virtual phis are analyzed separately. */ @@ -1611,7 +1623,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo) the dependences. FORNOW: fail at the first data dependence that we encounter. */ - ok = vect_analyze_data_ref_dependences (loop_vinfo, NULL, &max_vf); + ok = vect_analyze_data_ref_dependences (loop_vinfo, &max_vf); if (!ok || max_vf < min_vf) { @@ -1649,18 +1661,6 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo) return false; } - /* Analyze the access patterns of the data-refs in the loop (consecutive, - complex, etc.). FORNOW: Only handle consecutive access pattern. */ - - ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL); - if (!ok) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "bad data access."); - return false; - } - /* Prune the list of ddrs to be tested at run-time by versioning for alias. It is important to call pruning after vect_analyze_data_ref_accesses, since we use grouping information gathered by interleaving analysis. */ @@ -5772,11 +5772,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 3b2fc8013ba..8ef5d0684b4 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -2078,12 +2078,10 @@ 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; int min_vf = 2; - int max_vf = MAX_VECTORIZATION_FACTOR; bb_vinfo = new_bb_vec_info (bb); if (!bb_vinfo) @@ -2100,8 +2098,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, @@ -2112,10 +2109,20 @@ vect_slp_analyze_bb_1 (basic_block bb) return NULL; } + if (!vect_analyze_data_ref_accesses (NULL, bb_vinfo)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "not vectorized: unhandled data access in " + "basic block.\n"); + + destroy_bb_vec_info (bb_vinfo); + return NULL; + } + vect_pattern_recog (NULL, bb_vinfo); - if (!vect_analyze_data_ref_dependences (NULL, bb_vinfo, &max_vf) - || min_vf > max_vf) + if (!vect_slp_analyze_data_ref_dependences (bb_vinfo)) { if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, @@ -2137,17 +2144,6 @@ vect_slp_analyze_bb_1 (basic_block bb) return NULL; } - if (!vect_analyze_data_ref_accesses (NULL, bb_vinfo)) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "not vectorized: unhandled data access in " - "basic block.\n"); - - destroy_bb_vec_info (bb_vinfo); - return NULL; - } - /* Check the SLP opportunities in the basic block, analyze and build SLP trees. */ if (!vect_analyze_slp (NULL, bb_vinfo)) @@ -3181,7 +3177,15 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) unsigned int j; gimple_stmt_iterator gsi; - vect_remove_slp_scalar_calls (root); + /* Remove scalar call stmts. Do not do this for basic-block + vectorization as not all uses may be vectorized. + ??? Why should this be necessary? DCE should be able to + remove the stmts itself. + ??? For BB vectorization we can as well remove scalar + stmts starting from the SLP tree root if they have no + uses. */ + if (loop_vinfo) + vect_remove_slp_scalar_calls (root); for (j = 0; SLP_TREE_SCALAR_STMTS (root).iterate (j, &store) && j < SLP_INSTANCE_GROUP_SIZE (instance); j++) 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-vectorizer.h b/gcc/tree-vectorizer.h index bebffc73388..933245038c8 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -938,8 +938,8 @@ extern enum dr_alignment_support vect_supportable_dr_alignment (struct data_reference *, bool); extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *, HOST_WIDE_INT *); -extern bool vect_analyze_data_ref_dependences (loop_vec_info, bb_vec_info, - int *); +extern bool vect_analyze_data_ref_dependences (loop_vec_info, int *); +extern bool vect_slp_analyze_data_ref_dependences (bb_vec_info); extern bool vect_enhance_data_refs_alignment (loop_vec_info); extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info); extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info); diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index a38b14d4956..250a5063136 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -9329,7 +9329,11 @@ execute_vrp (void) } if (to_remove_edges.length () > 0) - free_dominance_info (CDI_DOMINATORS); + { + free_dominance_info (CDI_DOMINATORS); + if (current_loops) + loops_state_set (LOOPS_NEED_FIXUP); + } to_remove_edges.release (); to_update_switch_stmts.release (); diff --git a/gcc/tree.c b/gcc/tree.c index 43a72bc1b6a..0955cabc13d 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -975,6 +975,9 @@ copy_node_stat (tree node MEM_STAT_DECL) SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node)); DECL_HAS_VALUE_EXPR_P (t) = 1; } + /* DECL_DEBUG_EXPR is copied explicitely by callers. */ + if (TREE_CODE (node) == VAR_DECL) + DECL_HAS_DEBUG_EXPR_P (t) = 0; if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node)) { SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node)); @@ -6648,8 +6651,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 +6660,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/gcc/tree.h b/gcc/tree.h index f4f4f411bc2..d3ddf6ccce9 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -981,6 +981,10 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, #define STRIP_USELESS_TYPE_CONVERSION(EXP) \ (EXP) = tree_ssa_strip_useless_type_conversions (EXP) +/* Nonzero if TYPE represents a vector type. */ + +#define VECTOR_TYPE_P(TYPE) (TREE_CODE (TYPE) == VECTOR_TYPE) + /* Nonzero if TYPE represents an integral type. Note that we do not include COMPLEX types here. Keep these checks in ascending code order. */ @@ -1016,15 +1020,15 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, /* Nonzero if TYPE represents a vector integer type. */ -#define VECTOR_INTEGER_TYPE_P(TYPE) \ - (TREE_CODE (TYPE) == VECTOR_TYPE \ - && TREE_CODE (TREE_TYPE (TYPE)) == INTEGER_TYPE) +#define VECTOR_INTEGER_TYPE_P(TYPE) \ + (VECTOR_TYPE_P (TYPE) \ + && TREE_CODE (TREE_TYPE (TYPE)) == INTEGER_TYPE) /* Nonzero if TYPE represents a vector floating-point type. */ #define VECTOR_FLOAT_TYPE_P(TYPE) \ - (TREE_CODE (TYPE) == VECTOR_TYPE \ + (VECTOR_TYPE_P (TYPE) \ && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE) /* Nonzero if TYPE represents a floating-point type, including complex @@ -1034,7 +1038,7 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, #define FLOAT_TYPE_P(TYPE) \ (SCALAR_FLOAT_TYPE_P (TYPE) \ || ((TREE_CODE (TYPE) == COMPLEX_TYPE \ - || TREE_CODE (TYPE) == VECTOR_TYPE) \ + || VECTOR_TYPE_P (TYPE)) \ && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE)))) /* Nonzero if TYPE represents a decimal floating-point type. */ @@ -2116,7 +2120,7 @@ struct GTY(()) tree_block { /* Vector types need to check target flags to determine type. */ extern enum machine_mode vector_type_mode (const_tree); #define TYPE_MODE(NODE) \ - (TREE_CODE (TYPE_CHECK (NODE)) == VECTOR_TYPE \ + (VECTOR_TYPE_P (TYPE_CHECK (NODE)) \ ? vector_type_mode (NODE) : (NODE)->type_common.mode) #define SET_TYPE_MODE(NODE, MODE) \ (TYPE_CHECK (NODE)->type_common.mode = (MODE)) @@ -2709,8 +2713,6 @@ struct GTY(()) tree_decl_minimal { checked before any access to the former. */ #define DECL_FUNCTION_CODE(NODE) \ (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code) -#define DECL_DEBUG_EXPR_IS_FROM(NODE) \ - (DECL_COMMON_CHECK (NODE)->decl_common.debug_expr_is_from) #define DECL_FUNCTION_PERSONALITY(NODE) \ (FUNCTION_DECL_CHECK (NODE)->function_decl.personality) @@ -3223,9 +3225,9 @@ struct GTY(()) tree_decl_with_vis { extern tree decl_debug_expr_lookup (tree); extern void decl_debug_expr_insert (tree, tree); -/* For VAR_DECL, this is set to either an expression that it was split - from (if DECL_DEBUG_EXPR_IS_FROM is true), otherwise a tree_list of - subexpressions that it was split into. */ +/* For VAR_DECL, this is set to an expression that it was split from. */ +#define DECL_HAS_DEBUG_EXPR_P(NODE) \ + (VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from) #define DECL_DEBUG_EXPR(NODE) \ (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE))) diff --git a/gcc/valtrack.c b/gcc/valtrack.c index 87ce3f665b0..997f68b5089 100644 --- a/gcc/valtrack.c +++ b/gcc/valtrack.c @@ -71,7 +71,11 @@ cleanup_auto_inc_dec (rtx src, enum machine_mode mem_mode ATTRIBUTE_UNUSED) /* SCRATCH must be shared because they represent distinct values. */ return x; case CLOBBER: - if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER) + /* Share clobbers of hard registers (like cc0), but do not share pseudo reg + clobbers or clobbers of hard registers that originated as pseudos. + This is needed to allow safe register renaming. */ + if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER + && ORIGINAL_REGNO (XEXP (x, 0)) == REGNO (XEXP (x, 0))) return x; break; diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c index 069ecff9f41..baa9092b6f9 100644 --- a/gcc/var-tracking.c +++ b/gcc/var-tracking.c @@ -1791,11 +1791,11 @@ vars_copy (variable_table_type dst, variable_table_type src) static inline tree var_debug_decl (tree decl) { - if (decl && DECL_P (decl) - && DECL_DEBUG_EXPR_IS_FROM (decl)) + if (decl && TREE_CODE (decl) == VAR_DECL + && DECL_HAS_DEBUG_EXPR_P (decl)) { tree debugdecl = DECL_DEBUG_EXPR (decl); - if (debugdecl && DECL_P (debugdecl)) + if (DECL_P (debugdecl)) decl = debugdecl; } @@ -5048,12 +5048,10 @@ track_expr_p (tree expr, bool need_rtl) don't need to track this expression if the ultimate declaration is ignored. */ realdecl = expr; - if (DECL_DEBUG_EXPR_IS_FROM (realdecl)) + if (TREE_CODE (realdecl) == VAR_DECL && DECL_HAS_DEBUG_EXPR_P (realdecl)) { realdecl = DECL_DEBUG_EXPR (realdecl); - if (realdecl == NULL_TREE) - realdecl = expr; - else if (!DECL_P (realdecl)) + if (!DECL_P (realdecl)) { if (handled_component_p (realdecl) || (TREE_CODE (realdecl) == MEM_REF diff --git a/libatomic/gcas.c b/libatomic/gcas.c index edbf611f1b4..e3d77f3f558 100644 --- a/libatomic/gcas.c +++ b/libatomic/gcas.c @@ -32,7 +32,7 @@ # define EXACT_INLINE(N) \ if (C2(HAVE_ATOMIC_CAS_,N)) \ return __atomic_compare_exchange_n \ - (PTR(N,mptr), PTR(N,eptr), *PTR(N,dptr), false, smodel, fmodel) + (PTR(N,mptr), PTR(N,eptr), *PTR(N,dptr), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) #else # define EXACT_INLINE(N) #endif diff --git a/libatomic/gexch.c b/libatomic/gexch.c index 1999067df18..c8c86587bc2 100644 --- a/libatomic/gexch.c +++ b/libatomic/gexch.c @@ -33,7 +33,7 @@ if (C2(HAVE_ATOMIC_EXCHANGE_,N)) \ { \ *PTR(N,rptr) = __atomic_exchange_n \ - (PTR(N,mptr), *PTR(N,vptr), smodel); \ + (PTR(N,mptr), *PTR(N,vptr), __ATOMIC_SEQ_CST); \ return; \ } #else diff --git a/libatomic/gload.c b/libatomic/gload.c index df318d53f1f..85865bda535 100644 --- a/libatomic/gload.c +++ b/libatomic/gload.c @@ -32,7 +32,7 @@ # define EXACT_INLINE(N, DEST, SRC, DONE) \ if (C2(HAVE_ATOMIC_LDST_,N)) \ { \ - DEST = __atomic_load_n (SRC, smodel); \ + DEST = __atomic_load_n (SRC, __ATOMIC_SEQ_CST); \ DONE; \ } #else diff --git a/libatomic/gstore.c b/libatomic/gstore.c index d571e581bdc..84f9a8d5474 100644 --- a/libatomic/gstore.c +++ b/libatomic/gstore.c @@ -32,7 +32,7 @@ # define EXACT_INLINE(N) \ if (C2(HAVE_ATOMIC_LDST_,N)) \ { \ - __atomic_store_n (PTR(N,mptr), *PTR(N,vptr), smodel); \ + __atomic_store_n (PTR(N,mptr), *PTR(N,vptr), __ATOMIC_SEQ_CST); \ return; \ } #else diff --git a/libcpp/po/ChangeLog b/libcpp/po/ChangeLog index a3da0fc560b..93a18a5a276 100644 --- a/libcpp/po/ChangeLog +++ b/libcpp/po/ChangeLog @@ -1,3 +1,7 @@ +2013-03-15 Joseph Myers <joseph@codesourcery.com> + + * cpplib.pot: Regenerate. + 2013-03-09 Joseph Myers <joseph@codesourcery.com> * de.po: Update. diff --git a/libcpp/po/cpplib.pot b/libcpp/po/cpplib.pot index 074cd683db3..886ea740a50 100644 --- a/libcpp/po/cpplib.pot +++ b/libcpp/po/cpplib.pot @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" -"POT-Creation-Date: 2013-02-24 01:05+0000\n" +"POT-Creation-Date: 2013-03-15 17:42+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" "Language-Team: LANGUAGE <LL@li.org>\n" @@ -409,7 +409,7 @@ msgstr "" msgid "\"%s\" re-asserted" msgstr "" -#: directives.c:2566 +#: directives.c:2567 #, c-format msgid "unterminated #%s" msgstr "" @@ -585,39 +585,39 @@ msgstr "" msgid "division by zero in #if" msgstr "" -#: files.c:504 +#: files.c:505 msgid "NULL directory in find_file" msgstr "" -#: files.c:542 +#: files.c:553 msgid "one or more PCH files were found, but they were invalid" msgstr "" -#: files.c:545 +#: files.c:556 msgid "use -Winvalid-pch for more information" msgstr "" -#: files.c:643 +#: files.c:660 #, c-format msgid "%s is a block device" msgstr "" -#: files.c:660 +#: files.c:677 #, c-format msgid "%s is too large" msgstr "" -#: files.c:700 +#: files.c:717 #, c-format msgid "%s is shorter than expected" msgstr "" -#: files.c:935 +#: files.c:953 #, c-format msgid "no include path in which to search for %s" msgstr "" -#: files.c:1363 +#: files.c:1381 msgid "Multiple include guards may be useful for:\n" msgstr "" @@ -894,42 +894,42 @@ msgid "invalid hash type %d in cpp_macro_definition" msgstr "" #: pch.c:87 -#: pch.c:335 -#: pch.c:347 -#: pch.c:365 -#: pch.c:371 -#: pch.c:380 -#: pch.c:387 +#: pch.c:345 +#: pch.c:359 +#: pch.c:377 +#: pch.c:383 +#: pch.c:392 +#: pch.c:399 msgid "while writing precompiled header" msgstr "" -#: pch.c:607 +#: pch.c:619 #, c-format msgid "%s: not used because `%.*s' is poisoned" msgstr "" -#: pch.c:629 +#: pch.c:641 #, c-format msgid "%s: not used because `%.*s' not defined" msgstr "" -#: pch.c:641 +#: pch.c:653 #, c-format msgid "%s: not used because `%.*s' defined as `%s' not `%.*s'" msgstr "" -#: pch.c:682 +#: pch.c:694 #, c-format msgid "%s: not used because `%s' is defined" msgstr "" -#: pch.c:702 +#: pch.c:714 #, c-format msgid "%s: not used because `__COUNTER__' is invalid" msgstr "" -#: pch.c:711 -#: pch.c:886 +#: pch.c:723 +#: pch.c:898 msgid "while reading precompiled header" msgstr "" diff --git a/libffi/ChangeLog b/libffi/ChangeLog index 57cf3567213..23a6a7800a4 100644 --- a/libffi/ChangeLog +++ b/libffi/ChangeLog @@ -1,3 +1,8 @@ +2013-03-22 Kai Tietz <ktietz@redhat.com> + + * src/x86/win64.S: Make use of ffi_closure_win64_inner + symbol pc-relative. + 2013-03-07 Dave Korn <dave.korn.cygwin@gmail.com> * src/closures.c (is_emutramp_enabled [!FFI_MMAP_EXEC_EMUTRAMP_PAX]): diff --git a/libffi/src/x86/win64.S b/libffi/src/x86/win64.S index fcdb270faf5..1394cf177b6 100644 --- a/libffi/src/x86/win64.S +++ b/libffi/src/x86/win64.S @@ -295,7 +295,7 @@ SYMBOL_NAME(ffi_closure_win64): mov %rax, %rcx # context is first parameter mov %rsp, %rdx # stack is second parameter add $48, %rdx # point to start of arguments - mov $SYMBOL_NAME(ffi_closure_win64_inner), %rax + leaq SYMBOL_NAME(ffi_closure_win64_inner)(%rip), %rax callq *%rax # call the real closure function add $40, %rsp movq %rax, %xmm0 # If the closure returned a float, diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog index fe08adb12aa..e0556b45012 100644 --- a/libgcc/ChangeLog +++ b/libgcc/ChangeLog @@ -1,3 +1,31 @@ +2013-03-20 Robert Mason <rbmj@verizon.net> + + * config/vxlib-tls.c (__gthread_get_tsd_data,) + (__gthread_set_tsd_data, __gthread_enter_tsd_dtor_context,) + (__gthread_leave_tsd_dtor_context): Add prototypes. + (tls_delete_hook): Update. + +2013-03-20 Catherine Moore <clm@codesourcery.com> + Joseph Myers <joseph@codesourcery.com> + Chao-ying Fu <fu@mips.com> + + * config/mips/mips16.S: Don't build for microMIPS. + * config/mips/linux-unwind.h: Handle microMIPS frame. + * config/mips/crtn.S (fini, init): New labels. + +2013-03-14 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/53265 + * unwind-dw2.c (execute_cfa_program): Avoid + -Waggressive-array-optimizations warnings for DW_CFA_GNU_window_save + on targets with DWARF_FRAME_REGISTERS < 32. + +2013-03-13 Oleg Endo <olegendo@gcc.gnu.org> + + PR target/49880 + * config/sh/lib1funcs.S (sdivsi3_i4, udivsi3_i4): Enable for SH2A. + (sdivsi3, udivsi3): Remove SH4 check and always compile these functions. + 2013-03-07 Sriraman Tallam <tmsriram@google.com> * config/i386/cpuinfo.c (get_intel_cpu): Fix cpuid codes for diff --git a/libgcc/config/mips/crtn.S b/libgcc/config/mips/crtn.S index 59d1a905c11..99007176db2 100644 --- a/libgcc/config/mips/crtn.S +++ b/libgcc/config/mips/crtn.S @@ -31,6 +31,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #endif .section .init,"ax",@progbits +init: #ifdef __mips64 ld RA,40($sp) daddu $sp,$sp,48 @@ -41,6 +42,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see j RA .section .fini,"ax",@progbits +fini: #ifdef __mips64 ld RA,40($sp) daddu $sp,$sp,48 diff --git a/libgcc/config/mips/linux-unwind.h b/libgcc/config/mips/linux-unwind.h index a009797195c..92c2941ef42 100644 --- a/libgcc/config/mips/linux-unwind.h +++ b/libgcc/config/mips/linux-unwind.h @@ -51,6 +51,11 @@ mips_fallback_frame_state (struct _Unwind_Context *context, _Unwind_Ptr new_cfa, reg_offset; int i; + /* A MIPS16 or microMIPS frame. Signal frames always use the standard + ISA encoding. */ + if ((_Unwind_Ptr) pc & 3) + return _URC_END_OF_STACK; + /* 24021061 li v0, 0x1061 (rt_sigreturn)*/ /* 0000000c syscall */ /* or */ diff --git a/libgcc/config/mips/mips16.S b/libgcc/config/mips/mips16.S index ab3a7942d6c..82675018002 100644 --- a/libgcc/config/mips/mips16.S +++ b/libgcc/config/mips/mips16.S @@ -21,6 +21,10 @@ a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. */ +#ifdef __mips_micromips + /* DO NOTHING */ +#else + /* This file contains mips16 floating point support functions. These functions are called by mips16 code to handle floating point when -msoft-float is not used. They accept the arguments and return @@ -718,3 +722,4 @@ CALL_STUB_RET (__mips16_call_stub_dc_10, 10, DC) #endif /* !__mips_single_float */ #endif +#endif /* __mips_micromips */ diff --git a/libgcc/config/sh/lib1funcs.S b/libgcc/config/sh/lib1funcs.S index 56257190421..5f0bbff264f 100644 --- a/libgcc/config/sh/lib1funcs.S +++ b/libgcc/config/sh/lib1funcs.S @@ -1006,7 +1006,7 @@ hiset: sts macl,r0 ! r0 = bb*dd #ifdef L_sdivsi3_i4 .title "SH DIVIDE" !! 4 byte integer Divide code for the Renesas SH -#ifdef __SH4__ +#if defined (__SH4__) || defined (__SH2A__) !! args in r4 and r5, result in fpul, clobber dr0, dr2 .global GLOBAL(sdivsi3_i4) @@ -1021,7 +1021,7 @@ GLOBAL(sdivsi3_i4): ftrc dr0,fpul ENDFUNC(GLOBAL(sdivsi3_i4)) -#elif defined(__SH4_SINGLE__) || defined(__SH4_SINGLE_ONLY__) || (defined (__SH5__) && ! defined __SH4_NOFPU__) +#elif defined (__SH2A_SINGLE__) || defined (__SH2A_SINGLE_ONLY__) || defined(__SH4_SINGLE__) || defined(__SH4_SINGLE_ONLY__) || (defined (__SH5__) && ! defined __SH4_NOFPU__) !! args in r4 and r5, result in fpul, clobber r2, dr0, dr2 #if ! __SH5__ || __SH5__ == 32 @@ -1046,13 +1046,12 @@ GLOBAL(sdivsi3_i4): ENDFUNC(GLOBAL(sdivsi3_i4)) #endif /* ! __SH5__ || __SH5__ == 32 */ -#endif /* ! __SH4__ */ +#endif /* ! __SH4__ || __SH2A__ */ #endif #ifdef L_sdivsi3 /* __SH4_SINGLE_ONLY__ keeps this part for link compatibility with sh2e/sh3e code. */ -#if (! defined(__SH4__) && ! defined (__SH4_SINGLE__)) || defined (__linux__) !! !! Steve Chamberlain !! sac@cygnus.com @@ -1369,13 +1368,12 @@ div0: rts ENDFUNC(GLOBAL(sdivsi3)) #endif /* ! __SHMEDIA__ */ -#endif /* ! __SH4__ */ #endif #ifdef L_udivsi3_i4 .title "SH DIVIDE" !! 4 byte integer Divide code for the Renesas SH -#ifdef __SH4__ +#if defined (__SH4__) || defined (__SH2A__) !! args in r4 and r5, result in fpul, clobber r0, r1, r4, r5, dr0, dr2, dr4, !! and t bit @@ -1417,7 +1415,7 @@ L1: .double 2147483648 ENDFUNC(GLOBAL(udivsi3_i4)) -#elif defined (__SH5__) && ! defined (__SH4_NOFPU__) +#elif defined (__SH5__) && ! defined (__SH4_NOFPU__) && ! defined (__SH2A_NOFPU__) #if ! __SH5__ || __SH5__ == 32 !! args in r4 and r5, result in fpul, clobber r20, r21, dr0, fr33 .mode SHmedia @@ -1438,7 +1436,7 @@ GLOBAL(udivsi3_i4): ENDFUNC(GLOBAL(udivsi3_i4)) #endif /* ! __SH5__ || __SH5__ == 32 */ -#elif defined(__SH4_SINGLE__) || defined(__SH4_SINGLE_ONLY__) +#elif defined (__SH2A_SINGLE__) || defined (__SH2A_SINGLE_ONLY__) || defined(__SH4_SINGLE__) || defined(__SH4_SINGLE_ONLY__) !! args in r4 and r5, result in fpul, clobber r0, r1, r4, r5, dr0, dr2, dr4 .global GLOBAL(udivsi3_i4) @@ -1493,7 +1491,6 @@ L1: #ifdef L_udivsi3 /* __SH4_SINGLE_ONLY__ keeps this part for link compatibility with sh2e/sh3e code. */ -#if (! defined(__SH4__) && ! defined (__SH4_SINGLE__)) || defined (__linux__) !! args in r4 and r5, result in r0, clobbers r4, pr, and t bit .global GLOBAL(udivsi3) @@ -1688,7 +1685,6 @@ LOCAL(large_divisor): ENDFUNC(GLOBAL(udivsi3)) #endif /* ! __SHMEDIA__ */ -#endif /* __SH4__ */ #endif /* L_udivsi3 */ #ifdef L_udivdi3 diff --git a/libgcc/config/vxlib-tls.c b/libgcc/config/vxlib-tls.c index 8f88c6f2ab4..5c696034b37 100644 --- a/libgcc/config/vxlib-tls.c +++ b/libgcc/config/vxlib-tls.c @@ -102,6 +102,14 @@ extern void __gthread_set_tls_data (void *data); extern void __gthread_enter_tls_dtor_context (void); extern void __gthread_leave_tls_dtor_context (void); +#ifndef __RTP__ + +extern void *__gthread_get_tsd_data (WIND_TCB *tcb); +extern void __gthread_set_tsd_data (WIND_TCB *tcb, void *data); +extern void __gthread_enter_tsd_dtor_context (WIND_TCB *tcb); +extern void __gthread_leave_tsd_dtor_context (WIND_TCB *tcb); + +#endif /* __RTP__ */ /* This is a global structure which records all of the active keys. @@ -185,7 +193,7 @@ tls_delete_hook (void *tcb ATTRIBUTE_UNUSED) #ifdef __RTP__ __gthread_leave_tls_dtor_context (); #else - __gthread_leave_tsd_dtor_context (); + __gthread_leave_tsd_dtor_context (tcb); #endif #ifdef __RTP__ diff --git a/libgcc/unwind-dw2.c b/libgcc/unwind-dw2.c index 101a828b556..80de5ab1894 100644 --- a/libgcc/unwind-dw2.c +++ b/libgcc/unwind-dw2.c @@ -1128,11 +1128,12 @@ execute_cfa_program (const unsigned char *insn_ptr, case DW_CFA_GNU_window_save: /* ??? Hardcoded for SPARC register window configuration. */ - for (reg = 16; reg < 32; ++reg) - { - fs->regs.reg[reg].how = REG_SAVED_OFFSET; - fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *); - } + if (DWARF_FRAME_REGISTERS >= 32) + for (reg = 16; reg < 32; ++reg) + { + fs->regs.reg[reg].how = REG_SAVED_OFFSET; + fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *); + } break; case DW_CFA_GNU_args_size: diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog index 5412835903a..865725fbffa 100644 --- a/libgfortran/ChangeLog +++ b/libgfortran/ChangeLog @@ -1,3 +1,40 @@ +2013-03-24 Tobias Burnus <burnus@net-b.de> + + PR fortran/56696 + * io/list_read.c (read_real): Fix EOF diagnostic. + +2013-03-20 Tilo Schwarz <tilo@tilo-schwarz.de> + + PR libfortran/51825 + * io/list_read.c (nml_read_obj): Don't end the component loop on a + nested derived type, but continue with the next loop iteration. + (nml_get_obj_data): Don't move the first_nl pointer further in the + list if a qualifier was found. + +2013-03-20 Tilo Schwarz <tilo@tilo-schwarz.de> + + PR libfortran/48618 + * io/open.c (st_open): Raise error for unit number < 0 only if + unit number does not exist already. + +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..e7ae98fcf28 100644 --- a/libgfortran/io/list_read.c +++ b/libgfortran/io/list_read.c @@ -1433,7 +1433,6 @@ read_real (st_parameter_dt *dtp, void * dest, int length) goto got_sign; CASE_SEPARATORS: - case EOF: unget_char (dtp, c); /* Single null. */ eat_separator (dtp); return; @@ -2052,7 +2051,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 +2078,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 +2092,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 +2111,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 +2140,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 +2278,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 +2466,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 +2484,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 +2531,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); @@ -2578,30 +2577,30 @@ nml_read_obj (st_parameter_dt *dtp, namelist_info * nl, index_type offset, since a single object can have multiple reads. */ dtp->u.p.expanded_read = 0; - /* Now loop over the components. Update the component pointer - with the return value from nml_write_obj. This loop jumps - past nested derived types by testing if the potential - component name contains '%'. */ + /* Now loop over the components. */ for (cmp = nl->next; cmp && - !strncmp (cmp->var_name, obj_name, obj_name_len) && - !strchr (cmp->var_name + obj_name_len, '%'); + !strncmp (cmp->var_name, obj_name, obj_name_len); cmp = cmp->next) { + /* Jump over nested derived type by testing if the potential + component name contains '%'. */ + if (strchr (cmp->var_name + obj_name_len, '%')) + continue; - 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 +2624,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 +2710,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 +2724,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 +2742,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 +2763,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 +2780,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 +2805,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 +2865,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 +2881,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) @@ -2901,14 +2900,15 @@ get_name: goto nml_err_ret; } - if (*pprev_nl == NULL || !component_flag) + /* Don't move first_nl further in the list if a qualifier was found. */ + if ((*pprev_nl == NULL && !qualifier_flag) || !component_flag) first_nl = nl; root_nl = nl; 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/open.c b/libgfortran/io/open.c index d9cfde853f5..19fab1d683f 100644 --- a/libgfortran/io/open.c +++ b/libgfortran/io/open.c @@ -818,10 +818,6 @@ st_open (st_parameter_open *opp) flags.convert = conv; - if (!(opp->common.flags & IOPARM_OPEN_HAS_NEWUNIT) && opp->common.unit < 0) - generate_error (&opp->common, LIBERROR_BAD_OPTION, - "Bad unit number in OPEN statement"); - if (flags.position != POSITION_UNSPECIFIED && flags.access == ACCESS_DIRECT) generate_error (&opp->common, LIBERROR_BAD_OPTION, @@ -848,8 +844,16 @@ st_open (st_parameter_open *opp) { if ((opp->common.flags & IOPARM_OPEN_HAS_NEWUNIT)) opp->common.unit = get_unique_unit_number(opp); + else if (opp->common.unit < 0) + { + u = find_unit (opp->common.unit); + if (u == NULL) /* Negative unit and no NEWUNIT-created unit found. */ + generate_error (&opp->common, LIBERROR_BAD_OPTION, + "Bad unit number in OPEN statement"); + } - u = find_or_create_unit (opp->common.unit); + if (u == NULL) + u = find_or_create_unit (opp->common.unit); if (u->s == NULL) { u = new_unit (opp, u, &flags); 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/libitm/local_atomic b/libitm/local_atomic index 97e7d262769..4cd961af9ba 100644 --- a/libitm/local_atomic +++ b/libitm/local_atomic @@ -41,6 +41,10 @@ #ifndef _GLIBCXX_ATOMIC #define _GLIBCXX_ATOMIC 1 +#ifndef __always_inline +#define __always_inline inline __attribute__((always_inline)) +#endif + // #pragma GCC system_header // #ifndef __GXX_EXPERIMENTAL_CXX0X__ @@ -71,7 +75,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) memory_order_seq_cst } memory_order; - inline memory_order + __always_inline memory_order __calculate_memory_order(memory_order __m) noexcept { const bool __cond1 = __m == memory_order_release; @@ -81,13 +85,13 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __mo2; } - inline void + __always_inline void atomic_thread_fence(memory_order __m) noexcept { __atomic_thread_fence (__m); } - inline void + __always_inline void atomic_signal_fence(memory_order __m) noexcept { __atomic_thread_fence (__m); @@ -277,19 +281,19 @@ namespace std // _GLIBCXX_VISIBILITY(default) // Conversion to ATOMIC_FLAG_INIT. atomic_flag(bool __i) noexcept : __atomic_flag_base({ __i }) { } - bool + __always_inline bool test_and_set(memory_order __m = memory_order_seq_cst) noexcept { return __atomic_test_and_set (&_M_i, __m); } - bool + __always_inline bool test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_test_and_set (&_M_i, __m); } - void + __always_inline void clear(memory_order __m = memory_order_seq_cst) noexcept { // __glibcxx_assert(__m != memory_order_consume); @@ -299,7 +303,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_clear (&_M_i, __m); } - void + __always_inline void clear(memory_order __m = memory_order_seq_cst) volatile noexcept { // __glibcxx_assert(__m != memory_order_consume); @@ -452,7 +456,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); } - void + __always_inline void store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { // __glibcxx_assert(__m != memory_order_acquire); @@ -462,7 +466,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_i, __i, __m); } - void + __always_inline void store(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -473,7 +477,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_i, __i, __m); } - __int_type + __always_inline __int_type load(memory_order __m = memory_order_seq_cst) const noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -482,7 +486,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_i, __m); } - __int_type + __always_inline __int_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -491,22 +495,21 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_i, __m); } - __int_type + __always_inline __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_i, __i, __m); } - - __int_type + __always_inline __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_i, __i, __m); } - bool + __always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { @@ -517,7 +520,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); } - bool + __always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept @@ -529,7 +532,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); } - bool + __always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { @@ -537,7 +540,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - bool + __always_inline bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -545,7 +548,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - bool + __always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { @@ -556,7 +559,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); } - bool + __always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept @@ -568,7 +571,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); } - bool + __always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { @@ -576,7 +579,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - bool + __always_inline bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -584,52 +587,52 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __int_type + __always_inline __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_and(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_and(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_or(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_or(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_xor(&_M_i, __i, __m); } - __int_type + __always_inline __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_xor(&_M_i, __i, __m); } @@ -731,7 +734,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return __atomic_is_lock_free (sizeof (_M_p), &_M_p); } - void + __always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { @@ -742,7 +745,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_p, __p, __m); } - void + __always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -753,7 +756,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __atomic_store_n(&_M_p, __p, __m); } - __pointer_type + __always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -762,7 +765,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_p, __m); } - __pointer_type + __always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { // __glibcxx_assert(__m != memory_order_release); @@ -771,22 +774,21 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_load_n(&_M_p, __m); } - __pointer_type + __always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_p, __p, __m); } - - __pointer_type + __always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_p, __p, __m); } - bool + __always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept @@ -798,7 +800,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); } - bool + __always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept @@ -810,22 +812,22 @@ namespace std // _GLIBCXX_VISIBILITY(default) return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); } - __pointer_type + __always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_p, __d, __m); } - __pointer_type + __always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_p, __d, __m); } - __pointer_type + __always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_p, __d, __m); } - __pointer_type + __always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_p, __d, __m); } @@ -869,67 +871,67 @@ namespace std // _GLIBCXX_VISIBILITY(default) bool is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } - void + __always_inline void store(bool __i, memory_order __m = memory_order_seq_cst) noexcept { _M_base.store(__i, __m); } - void + __always_inline void store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { _M_base.store(__i, __m); } - bool + __always_inline bool load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_base.load(__m); } - bool + __always_inline bool load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_base.load(__m); } - bool + __always_inline bool exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.exchange(__i, __m); } - bool + __always_inline bool exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.exchange(__i, __m); } - bool + __always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } - bool + __always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } - bool + __always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } - bool + __always_inline bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } - bool + __always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } - bool + __always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } - bool + __always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } - bool + __always_inline bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } @@ -979,11 +981,11 @@ namespace std // _GLIBCXX_VISIBILITY(default) store(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept { __atomic_store(&_M_i, &__i, _m); } - void + __always_inline void store(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept { __atomic_store(&_M_i, &__i, _m); } - _Tp + __always_inline _Tp load(memory_order _m = memory_order_seq_cst) const noexcept { _Tp tmp; @@ -991,7 +993,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - _Tp + __always_inline _Tp load(memory_order _m = memory_order_seq_cst) const volatile noexcept { _Tp tmp; @@ -999,7 +1001,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - _Tp + __always_inline _Tp exchange(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept { _Tp tmp; @@ -1007,7 +1009,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - _Tp + __always_inline _Tp exchange(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept { @@ -1016,50 +1018,50 @@ namespace std // _GLIBCXX_VISIBILITY(default) return tmp; } - bool + __always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); } - bool + __always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); } - bool + __always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__e, __i, __m, __m); } - bool + __always_inline bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__e, __i, __m, __m); } - bool + __always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); } - bool + __always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); } - bool + __always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__e, __i, __m, __m); } - bool + __always_inline bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__e, __i, __m, __m); } @@ -1152,46 +1154,46 @@ namespace std // _GLIBCXX_VISIBILITY(default) is_lock_free() const volatile noexcept { return _M_b.is_lock_free(); } - void + __always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.store(__p, __m); } - void + __always_inline void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.store(__p, __m); } - __pointer_type + __always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_b.load(__m); } - __pointer_type + __always_inline __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_b.load(__m); } - __pointer_type + __always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.exchange(__p, __m); } - __pointer_type + __always_inline __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.exchange(__p, __m); } - bool + __always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - bool + __always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - bool + __always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { @@ -1199,7 +1201,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - bool + __always_inline bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -1207,18 +1209,18 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - bool + __always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - bool + __always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } - bool + __always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { @@ -1226,7 +1228,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - bool + __always_inline bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { @@ -1234,22 +1236,22 @@ namespace std // _GLIBCXX_VISIBILITY(default) __calculate_memory_order(__m)); } - __pointer_type + __always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.fetch_add(__d, __m); } - __pointer_type + __always_inline __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.fetch_add(__d, __m); } - __pointer_type + __always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.fetch_sub(__d, __m); } - __pointer_type + __always_inline __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.fetch_sub(__d, __m); } @@ -1543,98 +1545,98 @@ namespace std // _GLIBCXX_VISIBILITY(default) // Function definitions, atomic_flag operations. - inline bool + __always_inline bool atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline bool + __always_inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } - inline void + __always_inline void atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline void + __always_inline void atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } - inline bool + __always_inline bool atomic_flag_test_and_set(atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline bool + __always_inline bool atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } - inline void + __always_inline void atomic_flag_clear(atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } - inline void + __always_inline void atomic_flag_clear(volatile atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } // Function templates generally applicable to atomic types. template<typename _ITp> - inline bool + __always_inline bool atomic_is_lock_free(const atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template<typename _ITp> - inline bool + __always_inline bool atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template<typename _ITp> - inline void + __always_inline void atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept; template<typename _ITp> - inline void + __always_inline void atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept; template<typename _ITp> - inline void + __always_inline void atomic_store_explicit(atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { __a->store(__i, __m); } template<typename _ITp> - inline void + __always_inline void atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { __a->store(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_load_explicit(const volatile atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template<typename _ITp> - inline bool + __always_inline bool atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1642,7 +1644,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template<typename _ITp> - inline bool + __always_inline bool atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1650,7 +1652,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template<typename _ITp> - inline bool + __always_inline bool atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1658,7 +1660,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } template<typename _ITp> - inline bool + __always_inline bool atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2, memory_order __m1, @@ -1667,37 +1669,37 @@ namespace std // _GLIBCXX_VISIBILITY(default) template<typename _ITp> - inline void + __always_inline void atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline void + __always_inline void atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_load(const atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_load(const volatile atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline bool + __always_inline bool atomic_compare_exchange_weak(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1707,7 +1709,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - inline bool + __always_inline bool atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1717,7 +1719,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - inline bool + __always_inline bool atomic_compare_exchange_strong(atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1727,7 +1729,7 @@ namespace std // _GLIBCXX_VISIBILITY(default) } template<typename _ITp> - inline bool + __always_inline bool atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, _ITp* __i1, _ITp __i2) noexcept { @@ -1741,158 +1743,158 @@ namespace std // _GLIBCXX_VISIBILITY(default) // intergral types as specified in the standard, excluding address // types. template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } template<typename _ITp> - inline _ITp + __always_inline _ITp atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } // Partial specializations for pointers. template<typename _ITp> - inline _ITp* + __always_inline _ITp* atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_add(__d, __m); } template<typename _ITp> - inline _ITp* + __always_inline _ITp* atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_add(__d, __m); } template<typename _ITp> - inline _ITp* + __always_inline _ITp* atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_add(__d); } template<typename _ITp> - inline _ITp* + __always_inline _ITp* atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_add(__d); } template<typename _ITp> - inline _ITp* + __always_inline _ITp* atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_sub(__d, __m); } template<typename _ITp> - inline _ITp* + __always_inline _ITp* atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, memory_order __m) noexcept { return __a->fetch_sub(__d, __m); } template<typename _ITp> - inline _ITp* + __always_inline _ITp* atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_sub(__d); } template<typename _ITp> - inline _ITp* + __always_inline _ITp* atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept { return __a->fetch_sub(__d); } // @} group atomics diff --git a/libjava/ChangeLog b/libjava/ChangeLog index d5f508de4b7..7ad315ed8b9 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,9 @@ +2013-03-12 Andrew John Hughes <gnu.andrew@redhat.com> + + * include/posix-threads.h: + (_Jv_MutexCheckMonitor(_Jv_Mutex_t)): Use + pthread_equal rather than !=. + 2013-01-07 H.J. Lu <hongjiu.lu@intel.com> * Makefile.am (lib_gnu_awt_xlib_la_LDFLAGS): Replace diff --git a/libjava/include/posix-threads.h b/libjava/include/posix-threads.h index 59e65f74499..1ec311d7fa0 100644 --- a/libjava/include/posix-threads.h +++ b/libjava/include/posix-threads.h @@ -79,7 +79,7 @@ typedef struct inline int _Jv_MutexCheckMonitor (_Jv_Mutex_t *mu) { - return (mu->owner != pthread_self()); + return (pthread_equal(mu->owner, pthread_self()) == 0); } // Type identifying a POSIX thread. diff --git a/libmudflap/ChangeLog b/libmudflap/ChangeLog index 1872b2ebc4b..6e0d65c2fb7 100644 --- a/libmudflap/ChangeLog +++ b/libmudflap/ChangeLog @@ -1,3 +1,8 @@ +2013-03-14 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/53265 + * testsuite/libmudflap.c/fail37-frag.c: Add optimization barrier. + 2013-02-03 Richard Sandiford <rdsandiford@googlemail.com> Update copyright years. diff --git a/libmudflap/testsuite/libmudflap.c/fail37-frag.c b/libmudflap/testsuite/libmudflap.c/fail37-frag.c index 41ce4b91e05..38dbde56a81 100644 --- a/libmudflap/testsuite/libmudflap.c/fail37-frag.c +++ b/libmudflap/testsuite/libmudflap.c/fail37-frag.c @@ -13,7 +13,11 @@ main () { int i; for (i = 0; i < 5; i++) - x.s[i].f = 0; + { + /* Optimization barrier. Prevent gcc from seeing the undefined behavior. */ + __asm ("" : "+r" (i)); + x.s[i].f = 0; + } exit (0); } /* { dg-output "mudflap violation 1.*" } */ diff --git a/libsanitizer/ChangeLog b/libsanitizer/ChangeLog index 4e3facc1a8e..6d8d8af4e73 100644 --- a/libsanitizer/ChangeLog +++ b/libsanitizer/ChangeLog @@ -1,3 +1,13 @@ +2013-03-22 Jakub Jelinek <jakub@redhat.com> + + PR other/43620 + * configure.ac (AM_INIT_AUTOMAKE): Add no-dist. + * Makefile.in: Regenerated. + * asan/Makefile.in: Regenerated. + * interception/Makefile.in: Regenerated. + * sanitizer_common/Makefile.in: Regenerated. + * tsan/Makefile.in: Regenerated. + 2013-02-28 Jakub Jelinek <jakub@redhat.com> * asan/asan_mapping.h (kMidMemEnd): Increase to 0x4fffffffffULL. diff --git a/libsanitizer/Makefile.in b/libsanitizer/Makefile.in index 0ba5f881219..125692eb332 100644 --- a/libsanitizer/Makefile.in +++ b/libsanitizer/Makefile.in @@ -35,11 +35,9 @@ build_triplet = @build@ host_triplet = @host@ target_triplet = @target@ subdir = . -DIST_COMMON = $(am__configure_deps) $(srcdir)/../config.guess \ - $(srcdir)/../config.sub $(srcdir)/../install-sh \ - $(srcdir)/../ltmain.sh $(srcdir)/../missing \ - $(srcdir)/../mkinstalldirs $(srcdir)/Makefile.am \ - $(srcdir)/Makefile.in $(top_srcdir)/configure ChangeLog +DIST_COMMON = ChangeLog $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(top_srcdir)/configure $(am__configure_deps) \ + $(srcdir)/../mkinstalldirs ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \ $(top_srcdir)/../config/depstand.m4 \ @@ -59,7 +57,6 @@ mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = SOURCES = -DIST_SOURCES = MULTISRCTOP = MULTIBUILDTOP = MULTIDIRS = @@ -76,47 +73,10 @@ RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ distclean-recursive maintainer-clean-recursive AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \ - $(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \ - distdir dist dist-all distcheck + $(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS ETAGS = etags CTAGS = ctags DIST_SUBDIRS = interception sanitizer_common asan tsan -DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) -distdir = $(PACKAGE)-$(VERSION) -top_distdir = $(distdir) -am__remove_distdir = \ - { test ! -d "$(distdir)" \ - || { find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ - && rm -fr "$(distdir)"; }; } -am__relativize = \ - dir0=`pwd`; \ - sed_first='s,^\([^/]*\)/.*$$,\1,'; \ - sed_rest='s,^[^/]*/*,,'; \ - sed_last='s,^.*/\([^/]*\)$$,\1,'; \ - sed_butlast='s,/*[^/]*$$,,'; \ - while test -n "$$dir1"; do \ - first=`echo "$$dir1" | sed -e "$$sed_first"`; \ - if test "$$first" != "."; then \ - if test "$$first" = ".."; then \ - dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ - dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ - else \ - first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ - if test "$$first2" = "$$first"; then \ - dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ - else \ - dir2="../$$dir2"; \ - fi; \ - dir0="$$dir0"/"$$first"; \ - fi; \ - fi; \ - dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ - done; \ - reldir="$$dir2" -DIST_ARCHIVES = $(distdir).tar.gz -GZIP_ENV = --best -distuninstallcheck_listfiles = find . -type f -print -distcleancheck_listfiles = find . -type f -print ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AR = @AR@ @@ -490,182 +450,6 @@ GTAGS: distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags - -distdir: $(DISTFILES) - $(am__remove_distdir) - test -d "$(distdir)" || mkdir "$(distdir)" - @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - list='$(DISTFILES)'; \ - dist_files=`for file in $$list; do echo $$file; done | \ - sed -e "s|^$$srcdirstrip/||;t" \ - -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ - case $$dist_files in \ - */*) $(MKDIR_P) `echo "$$dist_files" | \ - sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ - sort -u` ;; \ - esac; \ - for file in $$dist_files; do \ - if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ - if test -d $$d/$$file; then \ - dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ - if test -d "$(distdir)/$$file"; then \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ - cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ - else \ - test -f "$(distdir)/$$file" \ - || cp -p $$d/$$file "$(distdir)/$$file" \ - || exit 1; \ - fi; \ - done - @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ - if test "$$subdir" = .; then :; else \ - test -d "$(distdir)/$$subdir" \ - || $(MKDIR_P) "$(distdir)/$$subdir" \ - || exit 1; \ - fi; \ - done - @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ - if test "$$subdir" = .; then :; else \ - dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ - $(am__relativize); \ - new_distdir=$$reldir; \ - dir1=$$subdir; dir2="$(top_distdir)"; \ - $(am__relativize); \ - new_top_distdir=$$reldir; \ - echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ - echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ - ($(am__cd) $$subdir && \ - $(MAKE) $(AM_MAKEFLAGS) \ - top_distdir="$$new_top_distdir" \ - distdir="$$new_distdir" \ - am__remove_distdir=: \ - am__skip_length_check=: \ - am__skip_mode_fix=: \ - distdir) \ - || exit 1; \ - fi; \ - done - -test -n "$(am__skip_mode_fix)" \ - || find "$(distdir)" -type d ! -perm -755 \ - -exec chmod u+rwx,go+rx {} \; -o \ - ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ - ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ - ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ - || chmod -R a+r "$(distdir)" -dist-gzip: distdir - tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz - $(am__remove_distdir) - -dist-bzip2: distdir - tardir=$(distdir) && $(am__tar) | bzip2 -9 -c >$(distdir).tar.bz2 - $(am__remove_distdir) - -dist-lzma: distdir - tardir=$(distdir) && $(am__tar) | lzma -9 -c >$(distdir).tar.lzma - $(am__remove_distdir) - -dist-xz: distdir - tardir=$(distdir) && $(am__tar) | xz -c >$(distdir).tar.xz - $(am__remove_distdir) - -dist-tarZ: distdir - tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z - $(am__remove_distdir) - -dist-shar: distdir - shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz - $(am__remove_distdir) - -dist-zip: distdir - -rm -f $(distdir).zip - zip -rq $(distdir).zip $(distdir) - $(am__remove_distdir) - -dist dist-all: distdir - tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz - $(am__remove_distdir) - -# This target untars the dist file and tries a VPATH configuration. Then -# it guarantees that the distribution is self-contained by making another -# tarfile. -distcheck: dist - case '$(DIST_ARCHIVES)' in \ - *.tar.gz*) \ - GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ - *.tar.bz2*) \ - bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ - *.tar.lzma*) \ - lzma -dc $(distdir).tar.lzma | $(am__untar) ;;\ - *.tar.xz*) \ - xz -dc $(distdir).tar.xz | $(am__untar) ;;\ - *.tar.Z*) \ - uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ - *.shar.gz*) \ - GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\ - *.zip*) \ - unzip $(distdir).zip ;;\ - esac - chmod -R a-w $(distdir); chmod a+w $(distdir) - mkdir $(distdir)/_build - mkdir $(distdir)/_inst - chmod a-w $(distdir) - test -d $(distdir)/_build || exit 0; \ - dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ - && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ - && am__cwd=`pwd` \ - && $(am__cd) $(distdir)/_build \ - && ../configure --srcdir=.. --prefix="$$dc_install_base" \ - $(DISTCHECK_CONFIGURE_FLAGS) \ - && $(MAKE) $(AM_MAKEFLAGS) \ - && $(MAKE) $(AM_MAKEFLAGS) dvi \ - && $(MAKE) $(AM_MAKEFLAGS) check \ - && $(MAKE) $(AM_MAKEFLAGS) install \ - && $(MAKE) $(AM_MAKEFLAGS) installcheck \ - && $(MAKE) $(AM_MAKEFLAGS) uninstall \ - && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ - distuninstallcheck \ - && chmod -R a-w "$$dc_install_base" \ - && ({ \ - (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ - && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ - && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ - && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ - distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ - } || { rm -rf "$$dc_destdir"; exit 1; }) \ - && rm -rf "$$dc_destdir" \ - && $(MAKE) $(AM_MAKEFLAGS) dist \ - && rm -rf $(DIST_ARCHIVES) \ - && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ - && cd "$$am__cwd" \ - || exit 1 - $(am__remove_distdir) - @(echo "$(distdir) archives ready for distribution: "; \ - list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ - sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' -distuninstallcheck: - @$(am__cd) '$(distuninstallcheck_dir)' \ - && test `$(distuninstallcheck_listfiles) | wc -l` -le 1 \ - || { echo "ERROR: files left after uninstall:" ; \ - if test -n "$(DESTDIR)"; then \ - echo " (check DESTDIR support)"; \ - fi ; \ - $(distuninstallcheck_listfiles) ; \ - exit 1; } >&2 -distcleancheck: distclean - @if test '$(srcdir)' = . ; then \ - echo "ERROR: distcleancheck can only run from a VPATH build" ; \ - exit 1 ; \ - fi - @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ - || { echo "ERROR: files left in build directory after distclean:" ; \ - $(distcleancheck_listfiles) ; \ - exit 1; } >&2 check-am: all-am check: check-recursive all-am: Makefile all-multi @@ -774,20 +558,17 @@ uninstall-am: .PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ all all-am all-multi am--refresh check check-am clean \ clean-generic clean-libtool clean-multi ctags ctags-recursive \ - dist dist-all dist-bzip2 dist-gzip dist-lzma dist-shar \ - dist-tarZ dist-xz dist-zip distcheck distclean \ - distclean-generic distclean-libtool distclean-multi \ - distclean-tags distcleancheck distdir distuninstallcheck dvi \ - dvi-am html html-am info info-am install install-am \ - install-data install-data-am install-dvi install-dvi-am \ - install-exec install-exec-am install-html install-html-am \ - install-info install-info-am install-man install-multi \ - install-pdf install-pdf-am install-ps install-ps-am \ - install-strip installcheck installcheck-am installdirs \ - installdirs-am maintainer-clean maintainer-clean-generic \ - maintainer-clean-multi mostlyclean mostlyclean-generic \ - mostlyclean-libtool mostlyclean-multi pdf pdf-am ps ps-am tags \ - tags-recursive uninstall uninstall-am + distclean distclean-generic distclean-libtool distclean-multi \ + distclean-tags dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-multi install-pdf install-pdf-am install-ps \ + install-ps-am install-strip installcheck installcheck-am \ + installdirs installdirs-am maintainer-clean \ + maintainer-clean-generic maintainer-clean-multi mostlyclean \ + mostlyclean-generic mostlyclean-libtool mostlyclean-multi pdf \ + pdf-am ps ps-am tags tags-recursive uninstall uninstall-am # Tell versions [3.59,3.63) of GNU make to not export all variables. diff --git a/libsanitizer/asan/Makefile.in b/libsanitizer/asan/Makefile.in index d54f3a7be36..1db6fa3da71 100644 --- a/libsanitizer/asan/Makefile.in +++ b/libsanitizer/asan/Makefile.in @@ -38,7 +38,7 @@ host_triplet = @host@ target_triplet = @target@ @USING_MAC_INTERPOSE_TRUE@am__append_1 = -DMAC_INTERPOSE_FUNCTIONS -DMISSING_BLOCKS_SUPPORT subdir = asan -DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \ $(top_srcdir)/../config/depstand.m4 \ @@ -111,11 +111,9 @@ CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \ $(LDFLAGS) -o $@ SOURCES = $(libasan_la_SOURCES) -DIST_SOURCES = $(libasan_la_SOURCES) HEADERS = $(nodist_toolexeclib_HEADERS) ETAGS = etags CTAGS = ctags -DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AR = @AR@ @@ -523,37 +521,6 @@ GTAGS: distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags - -distdir: $(DISTFILES) - @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - list='$(DISTFILES)'; \ - dist_files=`for file in $$list; do echo $$file; done | \ - sed -e "s|^$$srcdirstrip/||;t" \ - -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ - case $$dist_files in \ - */*) $(MKDIR_P) `echo "$$dist_files" | \ - sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ - sort -u` ;; \ - esac; \ - for file in $$dist_files; do \ - if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ - if test -d $$d/$$file; then \ - dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ - if test -d "$(distdir)/$$file"; then \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ - cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ - else \ - test -f "$(distdir)/$$file" \ - || cp -p $$d/$$file "$(distdir)/$$file" \ - || exit 1; \ - fi; \ - done check-am: all-am check: check-am all-am: Makefile $(LTLIBRARIES) $(HEADERS) @@ -664,8 +631,8 @@ uninstall-am: uninstall-nodist_toolexeclibHEADERS \ .PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ clean-libtool clean-toolexeclibLTLIBRARIES ctags distclean \ distclean-compile distclean-generic distclean-libtool \ - distclean-tags distdir dvi dvi-am html html-am info info-am \ - install install-am install-data install-data-am install-dvi \ + distclean-tags dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ install-dvi-am install-exec install-exec-am install-html \ install-html-am install-info install-info-am install-man \ install-nodist_toolexeclibHEADERS install-pdf install-pdf-am \ diff --git a/libsanitizer/configure.ac b/libsanitizer/configure.ac index fbeaf595540..3cf161d12de 100644 --- a/libsanitizer/configure.ac +++ b/libsanitizer/configure.ac @@ -23,7 +23,7 @@ target_alias=${target_alias-$host_alias} AC_SUBST(target_alias) GCC_LIBSTDCXX_RAW_CXX_FLAGS -AM_INIT_AUTOMAKE(foreign) +AM_INIT_AUTOMAKE(foreign no-dist) AM_ENABLE_MULTILIB(, ..) AM_MAINTAINER_MODE diff --git a/libsanitizer/interception/Makefile.in b/libsanitizer/interception/Makefile.in index f7c715b5c90..59b9a9a9f76 100644 --- a/libsanitizer/interception/Makefile.in +++ b/libsanitizer/interception/Makefile.in @@ -36,7 +36,7 @@ build_triplet = @build@ host_triplet = @host@ target_triplet = @target@ subdir = interception -DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \ $(top_srcdir)/../config/depstand.m4 \ @@ -73,10 +73,8 @@ CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \ $(LDFLAGS) -o $@ SOURCES = $(libinterception_la_SOURCES) -DIST_SOURCES = $(libinterception_la_SOURCES) ETAGS = etags CTAGS = ctags -DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AR = @AR@ @@ -400,37 +398,6 @@ GTAGS: distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags - -distdir: $(DISTFILES) - @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - list='$(DISTFILES)'; \ - dist_files=`for file in $$list; do echo $$file; done | \ - sed -e "s|^$$srcdirstrip/||;t" \ - -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ - case $$dist_files in \ - */*) $(MKDIR_P) `echo "$$dist_files" | \ - sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ - sort -u` ;; \ - esac; \ - for file in $$dist_files; do \ - if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ - if test -d $$d/$$file; then \ - dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ - if test -d "$(distdir)/$$file"; then \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ - cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ - else \ - test -f "$(distdir)/$$file" \ - || cp -p $$d/$$file "$(distdir)/$$file" \ - || exit 1; \ - fi; \ - done check-am: all-am check: check-am all-am: Makefile $(LTLIBRARIES) @@ -536,8 +503,8 @@ uninstall-am: .PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ clean-libtool clean-noinstLTLIBRARIES ctags distclean \ distclean-compile distclean-generic distclean-libtool \ - distclean-tags distdir dvi dvi-am html html-am info info-am \ - install install-am install-data install-data-am install-dvi \ + distclean-tags dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ install-dvi-am install-exec install-exec-am install-html \ install-html-am install-info install-info-am install-man \ install-pdf install-pdf-am install-ps install-ps-am \ diff --git a/libsanitizer/sanitizer_common/Makefile.in b/libsanitizer/sanitizer_common/Makefile.in index 8e292432765..a3030836d35 100644 --- a/libsanitizer/sanitizer_common/Makefile.in +++ b/libsanitizer/sanitizer_common/Makefile.in @@ -36,7 +36,7 @@ build_triplet = @build@ host_triplet = @host@ target_triplet = @target@ subdir = sanitizer_common -DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \ $(top_srcdir)/../config/depstand.m4 \ @@ -79,10 +79,8 @@ CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \ $(LDFLAGS) -o $@ SOURCES = $(libsanitizer_common_la_SOURCES) -DIST_SOURCES = $(libsanitizer_common_la_SOURCES) ETAGS = etags CTAGS = ctags -DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AR = @AR@ @@ -432,37 +430,6 @@ GTAGS: distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags - -distdir: $(DISTFILES) - @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - list='$(DISTFILES)'; \ - dist_files=`for file in $$list; do echo $$file; done | \ - sed -e "s|^$$srcdirstrip/||;t" \ - -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ - case $$dist_files in \ - */*) $(MKDIR_P) `echo "$$dist_files" | \ - sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ - sort -u` ;; \ - esac; \ - for file in $$dist_files; do \ - if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ - if test -d $$d/$$file; then \ - dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ - if test -d "$(distdir)/$$file"; then \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ - cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ - else \ - test -f "$(distdir)/$$file" \ - || cp -p $$d/$$file "$(distdir)/$$file" \ - || exit 1; \ - fi; \ - done check-am: all-am check: check-am all-am: Makefile $(LTLIBRARIES) @@ -568,8 +535,8 @@ uninstall-am: .PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ clean-libtool clean-noinstLTLIBRARIES ctags distclean \ distclean-compile distclean-generic distclean-libtool \ - distclean-tags distdir dvi dvi-am html html-am info info-am \ - install install-am install-data install-data-am install-dvi \ + distclean-tags dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ install-dvi-am install-exec install-exec-am install-html \ install-html-am install-info install-info-am install-man \ install-pdf install-pdf-am install-ps install-ps-am \ diff --git a/libsanitizer/tsan/Makefile.in b/libsanitizer/tsan/Makefile.in index 8c38beb308c..95a88b221e4 100644 --- a/libsanitizer/tsan/Makefile.in +++ b/libsanitizer/tsan/Makefile.in @@ -36,7 +36,7 @@ build_triplet = @build@ host_triplet = @host@ target_triplet = @target@ subdir = tsan -DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \ $(top_srcdir)/../config/depstand.m4 \ @@ -123,10 +123,8 @@ LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \ $(LDFLAGS) -o $@ SOURCES = $(libtsan_la_SOURCES) -DIST_SOURCES = $(libtsan_la_SOURCES) ETAGS = etags CTAGS = ctags -DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AR = @AR@ @@ -537,37 +535,6 @@ GTAGS: distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags - -distdir: $(DISTFILES) - @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - list='$(DISTFILES)'; \ - dist_files=`for file in $$list; do echo $$file; done | \ - sed -e "s|^$$srcdirstrip/||;t" \ - -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ - case $$dist_files in \ - */*) $(MKDIR_P) `echo "$$dist_files" | \ - sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ - sort -u` ;; \ - esac; \ - for file in $$dist_files; do \ - if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ - if test -d $$d/$$file; then \ - dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ - if test -d "$(distdir)/$$file"; then \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ - cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ - else \ - test -f "$(distdir)/$$file" \ - || cp -p $$d/$$file "$(distdir)/$$file" \ - || exit 1; \ - fi; \ - done check-am: all-am check: check-am all-am: Makefile $(LTLIBRARIES) @@ -676,8 +643,8 @@ uninstall-am: uninstall-toolexeclibLTLIBRARIES .PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ clean-libtool clean-toolexeclibLTLIBRARIES ctags distclean \ distclean-compile distclean-generic distclean-libtool \ - distclean-tags distdir dvi dvi-am html html-am info info-am \ - install install-am install-data install-data-am install-dvi \ + distclean-tags dvi dvi-am html html-am info info-am install \ + install-am install-data install-data-am install-dvi \ install-dvi-am install-exec install-exec-am install-html \ install-html-am install-info install-info-am install-man \ install-pdf install-pdf-am install-ps install-ps-am \ diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index c3b4924485d..c06d6ae5494 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,121 @@ +2013-03-25 Kai Tietz <ktietz@redhat.com> + + * testsuite/18_support/50594.cc: For mingw-targets use only static + libstdc++-version. + * testsuite/19_diagnostics/error_category/operators/equal.cc + * testsuite/19_diagnostics/error_code/cons/1.cc + * testsuite/19_diagnostics/error_code/operators/bool.cc + * testsuite/19_diagnostics/error_code/operators/equal.cc + * testsuite/19_diagnostics/error_code/operators/not_equal.cc + * testsuite/19_diagnostics/error_condition/cons/1.cc + * testsuite/19_diagnostics/error_condition/operators/bool.cc + * testsuite/19_diagnostics/error_condition/operators/equal.cc + * testsuite/19_diagnostics/error_condition/operators/not_equal.cc + * testsuite/23_containers/set/requirements/exception/basic.cc + * testsuite/26_numerics/headers/cmath/c99_classification_macros_c.cc + * testsuite/lib/dg-options.exp (dg-additional-options): New option. + +2013-03-24 Jonathan Wakely <jwakely.gcc@gmail.com> + + PR libstdc++/56170 + * include/ext/debug_allocator.h (debug_allocator): Add missing members + to meet allocator requirements. + * testsuite/ext/debug_allocator/56170.cc: New. + +2013-03-22 Paolo Carlini <paolo.carlini@oracle.com> + + PR libstdc++/56678 + * include/std/chrono (__is_ratio): Uglify T. + +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 + * include/std/future (__future_base::_Result): Add result_type + typedef. + (__future_base::_S_allocate_result): Overload for std::allocator. + (__future_base::_Task_setter): Use _Result::result_type instead of + deducing the type from the task. + (__future_base::_Task_state): Store allocator to allow shared state + to be reset. Replace std::function with member of target object type + accessed via ... + (__future_base::_Task_state_base): New abstract base class. + (__future_base::_Task_state_base::_M_run): New virtual function to + invoke type-erased target object. + (__future_base::_Task_state_base::_M_reset): New virtual function to + create new shared_state using same target object and allocator. + (__future_base::__create_task_state): Allocate a new _Task_state. + (packaged_task::packaged_task): Use __create_task_state. + (packaged_task::reset): Use _Task_state_base::_M_reset. + * testsuite/30_threads/packaged_task/cons/56492.cc: New. + +2013-03-15 Tom Tromey <tromey@redhat.com> + + * libsupc++/unwind-cxx.h: Include sys/sdt.h if detected. + (PROBE2): New macro. + * libsupc++/eh_throw.cc (__cxa_throw, __cxa_rethrow): Add probe. + * libsupc++/eh_catch.cc (__cxa_begin_catch): Add probe. + * configure.ac: Check for sys/sdt.h. + * configure, config.h.in: Rebuild. + +2013-03-14 Jonathan Wakely <jwakely.gcc@gmail.com> + + PR libstdc++/56613 + * include/bits/stl_tree.h (_Rb_tree::_M_create_node): Use + allocator_traits instead of calling construct directly. + * testsuite/23_containers/map/56613.cc: New. + +2013-03-13 Benjamin Kosnik <bkoz@redhat.com> + + * doc/html/*: Regenerate. + +2013-03-13 Paolo Carlini <paolo.carlini@oracle.com> + + PR libstdc++/56609 + * include/std/type_traits (is_fundamental): Add std::nullptr_t. + * testsuite/20_util/is_fundamental/value.cc: Extend. + * testsuite/20_util/is_compound/value.cc: Likewise. + 2013-03-09 Paolo Carlini <paolo.carlini@oracle.com> * testsuite/20_util/function_objects/mem_fn/55463.cc: Avoid diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in index 07a1e50be1f..9937a1ed155 100644 --- a/libstdc++-v3/config.h.in +++ b/libstdc++-v3/config.h.in @@ -400,6 +400,9 @@ /* Define to 1 if you have the <sys/resource.h> header file. */ #undef HAVE_SYS_RESOURCE_H +/* Define to 1 if you have the <sys/sdt.h> header file. */ +#undef HAVE_SYS_SDT_H + /* Define to 1 if you have the <sys/sem.h> header file. */ #undef HAVE_SYS_SEM_H diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure index fa44bacc448..f40ddcff99e 100755 --- a/libstdc++-v3/configure +++ b/libstdc++-v3/configure @@ -20417,7 +20417,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu for ac_header in endian.h execinfo.h float.h fp.h ieeefp.h inttypes.h \ locale.h machine/endian.h machine/param.h nan.h stdint.h stdlib.h string.h \ strings.h sys/ipc.h sys/isa_defs.h sys/machine.h sys/param.h \ -sys/resource.h sys/sem.h sys/stat.h sys/time.h sys/types.h unistd.h \ +sys/resource.h sys/sdt.h sys/sem.h sys/stat.h sys/time.h sys/types.h unistd.h \ wchar.h wctype.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` diff --git a/libstdc++-v3/configure.ac b/libstdc++-v3/configure.ac index a64fee28c2c..de664064491 100644 --- a/libstdc++-v3/configure.ac +++ b/libstdc++-v3/configure.ac @@ -216,7 +216,7 @@ GLIBCXX_CHECK_SYSCTL_HW_NCPU AC_CHECK_HEADERS([endian.h execinfo.h float.h fp.h ieeefp.h inttypes.h \ locale.h machine/endian.h machine/param.h nan.h stdint.h stdlib.h string.h \ strings.h sys/ipc.h sys/isa_defs.h sys/machine.h sys/param.h \ -sys/resource.h sys/sem.h sys/stat.h sys/time.h sys/types.h unistd.h \ +sys/resource.h sys/sdt.h sys/sem.h sys/stat.h sys/time.h sys/types.h unistd.h \ wchar.h wctype.h]) # Only do link tests if native. Else, hardcode. diff --git a/libstdc++-v3/doc/html/api.html b/libstdc++-v3/doc/html/api.html index 71c5e5544f1..cc338d23eeb 100644 --- a/libstdc++-v3/doc/html/api.html +++ b/libstdc++-v3/doc/html/api.html @@ -6,7 +6,7 @@ <a class="link" href="http://www.fsf.org/" target="_top">FSF </a> - </p></div><div><div class="legalnotice"><a id="idp4024576"></a><p> + </p></div><div><div class="legalnotice"><a id="idp3706336"></a><p> <a class="link" href="manual/license.html" title="License">License </a> </p></div></div></div><hr /></div><p> diff --git a/libstdc++-v3/doc/html/faq.html b/libstdc++-v3/doc/html/faq.html index 91952071e87..b90c93f9e5b 100644 --- a/libstdc++-v3/doc/html/faq.html +++ b/libstdc++-v3/doc/html/faq.html @@ -3,7 +3,7 @@ 2008, 2010 <a class="link" href="http://www.fsf.org" target="_top">FSF</a> - </p></div></div><hr /></div><div class="qandaset"><a id="idp2202288"></a><dl><dt></dt><dd><dl><dt>1.1. <a href="faq.html#faq.what"> + </p></div></div><hr /></div><div class="qandaset"><a id="idp1581728"></a><dl><dt></dt><dd><dl><dt>1.1. <a href="faq.html#faq.what"> What is libstdc++? </a></dt><dt>1.2. <a href="faq.html#faq.why"> Why should I use libstdc++? diff --git a/libstdc++-v3/doc/html/index.html b/libstdc++-v3/doc/html/index.html index 4ae8a07af40..7481dc9d04d 100644 --- a/libstdc++-v3/doc/html/index.html +++ b/libstdc++-v3/doc/html/index.html @@ -34,13 +34,13 @@ </a></span></dt><dd><dl><dt><span class="section"><a href="manual/diagnostics.html#std.diagnostics.exceptions">Exceptions</a></span></dt><dd><dl><dt><span class="section"><a href="manual/diagnostics.html#std.diagnostics.exceptions.api">API Reference</a></span></dt><dt><span class="section"><a href="manual/diagnostics.html#std.diagnostics.exceptions.data">Adding Data to <code class="classname">exception</code></a></span></dt></dl></dd><dt><span class="section"><a href="manual/concept_checking.html">Concept Checking</a></span></dt></dl></dd><dt><span class="chapter"><a href="manual/utilities.html">6. Utilities -</a></span></dt><dd><dl><dt><span class="section"><a href="manual/utilities.html#std.util.functors">Functors</a></span></dt><dt><span class="section"><a href="manual/pairs.html">Pairs</a></span></dt><dt><span class="section"><a href="manual/memory.html">Memory</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#std.util.memory.allocator">Allocators</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#allocator.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/memory.html#allocator.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="manual/memory.html#allocator.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#idp13918736">Interface Design</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp13922288">Selecting Default Allocation Policy</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp13935584">Disabling Memory Caching</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#allocator.using">Using a Specific Allocator</a></span></dt><dt><span class="section"><a href="manual/memory.html#allocator.custom">Custom Allocators</a></span></dt><dt><span class="section"><a href="manual/memory.html#allocator.ext">Extension Allocators</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#std.util.memory.auto_ptr">auto_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#auto_ptr.limitations">Limitations</a></span></dt><dt><span class="section"><a href="manual/memory.html#auto_ptr.using">Use in Containers</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#std.util.memory.shared_ptr">shared_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#shared_ptr.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/memory.html#shared_ptr.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="manual/memory.html#shared_ptr.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#idp15511664">Class Hierarchy</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp15534176">Thread Safety</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp15541472">Selecting Lock Policy</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp15556096">Related functions and classes</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#shared_ptr.using">Use</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#idp15572448">Examples</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp15576032">Unresolved Issues</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#shared_ptr.ack">Acknowledgments</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="manual/traits.html">Traits</a></span></dt></dl></dd><dt><span class="chapter"><a href="manual/strings.html">7. +</a></span></dt><dd><dl><dt><span class="section"><a href="manual/utilities.html#std.util.functors">Functors</a></span></dt><dt><span class="section"><a href="manual/pairs.html">Pairs</a></span></dt><dt><span class="section"><a href="manual/memory.html">Memory</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#std.util.memory.allocator">Allocators</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#allocator.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/memory.html#allocator.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="manual/memory.html#allocator.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#idp13920976">Interface Design</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp13924528">Selecting Default Allocation Policy</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp13937824">Disabling Memory Caching</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#allocator.using">Using a Specific Allocator</a></span></dt><dt><span class="section"><a href="manual/memory.html#allocator.custom">Custom Allocators</a></span></dt><dt><span class="section"><a href="manual/memory.html#allocator.ext">Extension Allocators</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#std.util.memory.auto_ptr">auto_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#auto_ptr.limitations">Limitations</a></span></dt><dt><span class="section"><a href="manual/memory.html#auto_ptr.using">Use in Containers</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#std.util.memory.shared_ptr">shared_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#shared_ptr.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/memory.html#shared_ptr.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="manual/memory.html#shared_ptr.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#idp15512272">Class Hierarchy</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp15534784">Thread Safety</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp15542080">Selecting Lock Policy</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp15556704">Related functions and classes</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#shared_ptr.using">Use</a></span></dt><dd><dl><dt><span class="section"><a href="manual/memory.html#idp15573056">Examples</a></span></dt><dt><span class="section"><a href="manual/memory.html#idp15576640">Unresolved Issues</a></span></dt></dl></dd><dt><span class="section"><a href="manual/memory.html#shared_ptr.ack">Acknowledgments</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="manual/traits.html">Traits</a></span></dt></dl></dd><dt><span class="chapter"><a href="manual/strings.html">7. Strings </a></span></dt><dd><dl><dt><span class="section"><a href="manual/strings.html#std.strings.string">String Classes</a></span></dt><dd><dl><dt><span class="section"><a href="manual/strings.html#strings.string.simple">Simple Transformations</a></span></dt><dt><span class="section"><a href="manual/strings.html#strings.string.case">Case Sensitivity</a></span></dt><dt><span class="section"><a href="manual/strings.html#strings.string.character_types">Arbitrary Character Types</a></span></dt><dt><span class="section"><a href="manual/strings.html#strings.string.token">Tokenizing</a></span></dt><dt><span class="section"><a href="manual/strings.html#strings.string.shrink">Shrink to Fit</a></span></dt><dt><span class="section"><a href="manual/strings.html#strings.string.Cstring">CString (MFC)</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="manual/localization.html">8. Localization -</a></span></dt><dd><dl><dt><span class="section"><a href="manual/localization.html#std.localization.locales">Locales</a></span></dt><dd><dl><dt><span class="section"><a href="manual/localization.html#std.localization.locales.locale">locale</a></span></dt><dd><dl><dt><span class="section"><a href="manual/localization.html#locales.locale.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/localization.html#locales.locale.design">Design</a></span></dt><dt><span class="section"><a href="manual/localization.html#locales.locale.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/localization.html#locale.impl.c">Interacting with "C" locales</a></span></dt></dl></dd><dt><span class="section"><a href="manual/localization.html#locales.locale.future">Future</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="manual/facets.html">Facets</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#std.localization.facet.ctype">ctype</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#facet.ctype.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#idp15777920">Specializations</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#facet.ctype.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#std.localization.facet.codecvt">codecvt</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#facet.codecvt.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.codecvt.design">Design</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#codecvt.design.wchar_t_size"><span class="type">wchar_t</span> Size</a></span></dt><dt><span class="section"><a href="manual/facets.html#codecvt.design.unicode">Support for Unicode</a></span></dt><dt><span class="section"><a href="manual/facets.html#codecvt.design.issues">Other Issues</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#facet.codecvt.impl">Implementation</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.codecvt.use">Use</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.codecvt.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#manual.localization.facet.messages">messages</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#facet.messages.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.messages.design">Design</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.messages.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#messages.impl.models">Models</a></span></dt><dt><span class="section"><a href="manual/facets.html#messages.impl.gnu">The GNU Model</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#facet.messages.use">Use</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.messages.future">Future</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="chapter"><a href="manual/containers.html">9. +</a></span></dt><dd><dl><dt><span class="section"><a href="manual/localization.html#std.localization.locales">Locales</a></span></dt><dd><dl><dt><span class="section"><a href="manual/localization.html#std.localization.locales.locale">locale</a></span></dt><dd><dl><dt><span class="section"><a href="manual/localization.html#locales.locale.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/localization.html#locales.locale.design">Design</a></span></dt><dt><span class="section"><a href="manual/localization.html#locales.locale.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/localization.html#locale.impl.c">Interacting with "C" locales</a></span></dt></dl></dd><dt><span class="section"><a href="manual/localization.html#locales.locale.future">Future</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="manual/facets.html">Facets</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#std.localization.facet.ctype">ctype</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#facet.ctype.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#idp15778336">Specializations</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#facet.ctype.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#std.localization.facet.codecvt">codecvt</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#facet.codecvt.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.codecvt.design">Design</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#codecvt.design.wchar_t_size"><span class="type">wchar_t</span> Size</a></span></dt><dt><span class="section"><a href="manual/facets.html#codecvt.design.unicode">Support for Unicode</a></span></dt><dt><span class="section"><a href="manual/facets.html#codecvt.design.issues">Other Issues</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#facet.codecvt.impl">Implementation</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.codecvt.use">Use</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.codecvt.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#manual.localization.facet.messages">messages</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#facet.messages.req">Requirements</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.messages.design">Design</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.messages.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="manual/facets.html#messages.impl.models">Models</a></span></dt><dt><span class="section"><a href="manual/facets.html#messages.impl.gnu">The GNU Model</a></span></dt></dl></dd><dt><span class="section"><a href="manual/facets.html#facet.messages.use">Use</a></span></dt><dt><span class="section"><a href="manual/facets.html#facet.messages.future">Future</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="chapter"><a href="manual/containers.html">9. Containers </a></span></dt><dd><dl><dt><span class="section"><a href="manual/containers.html#std.containers.sequences">Sequences</a></span></dt><dd><dl><dt><span class="section"><a href="manual/containers.html#containers.sequences.list">list</a></span></dt><dd><dl><dt><span class="section"><a href="manual/containers.html#sequences.list.size">list::size() is O(n)</a></span></dt></dl></dd><dt><span class="section"><a href="manual/containers.html#containers.sequences.vector">vector</a></span></dt><dd><dl><dt><span class="section"><a href="manual/containers.html#sequences.vector.management">Space Overhead Management</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="manual/associative.html">Associative</a></span></dt><dd><dl><dt><span class="section"><a href="manual/associative.html#containers.associative.insert_hints">Insertion Hints</a></span></dt><dt><span class="section"><a href="manual/associative.html#containers.associative.bitset">bitset</a></span></dt><dd><dl><dt><span class="section"><a href="manual/associative.html#associative.bitset.size_variable">Size Variable</a></span></dt><dt><span class="section"><a href="manual/associative.html#associative.bitset.type_string">Type String</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="manual/unordered_associative.html">Unordered Associative</a></span></dt><dd><dl><dt><span class="section"><a href="manual/unordered_associative.html#containers.unordered.hash">Hash Code</a></span></dt><dd><dl><dt><span class="section"><a href="manual/unordered_associative.html#containers.unordered.cache">Hash Code Caching Policy</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="manual/containers_and_c.html">Interacting with C</a></span></dt><dd><dl><dt><span class="section"><a href="manual/containers_and_c.html#containers.c.vs_array">Containers vs. Arrays</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="manual/iterators.html">10. diff --git a/libstdc++-v3/doc/html/manual/abi.html b/libstdc++-v3/doc/html/manual/abi.html index 8a9572a2c20..c5cf1edbb4b 100644 --- a/libstdc++-v3/doc/html/manual/abi.html +++ b/libstdc++-v3/doc/html/manual/abi.html @@ -493,39 +493,39 @@ gcc test.c -g -O2 -L. -lone -ltwo /usr/lib/libstdc++.so.5 /usr/lib/libstdc++.so. <a class="link" href="http://www.codesourcery.com/cxx-abi/" target="_top"> C++ ABI Summary </a> - </em>. </span></p></div><div class="biblioentry"><a id="idp22945360"></a><p><span class="title"><em> + </em>. </span></p></div><div class="biblioentry"><a id="idp22945936"></a><p><span class="title"><em> <a class="link" href="http://www.intel.com/cd/software/products/asmo-na/eng/284736.htm" target="_top"> Intel Compilers for Linux Compatibility with the GNU Compilers </a> - </em>. </span></p></div><div class="biblioentry"><a id="idp22947216"></a><p><span class="title"><em> + </em>. </span></p></div><div class="biblioentry"><a id="idp22947792"></a><p><span class="title"><em> <a class="link" href="http://download.oracle.com/docs/cd/E19963-01/html/819-0690/index.html" target="_top"> Linker and Libraries Guide (document 819-0690) </a> - </em>. </span></p></div><div class="biblioentry"><a id="idp22949056"></a><p><span class="title"><em> + </em>. </span></p></div><div class="biblioentry"><a id="idp22949632"></a><p><span class="title"><em> <a class="link" href="http://download.oracle.com/docs/cd/E19422-01/819-3689/index.html" target="_top"> Sun Studio 11: C++ Migration Guide (document 819-3689) </a> - </em>. </span></p></div><div class="biblioentry"><a id="idp22950912"></a><p><span class="title"><em> + </em>. </span></p></div><div class="biblioentry"><a id="idp22951488"></a><p><span class="title"><em> <a class="link" href="http://www.akkadia.org/drepper/dsohowto.pdf" target="_top"> How to Write Shared Libraries </a> - </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span></p></div><div class="biblioentry"><a id="idp22954352"></a><p><span class="title"><em> + </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span></p></div><div class="biblioentry"><a id="idp22954928"></a><p><span class="title"><em> <a class="link" href="http://www.arm.com/miscPDFs/8033.pdf" target="_top"> C++ ABI for the ARM Architecture </a> - </em>. </span></p></div><div class="biblioentry"><a id="idp22956160"></a><p><span class="title"><em> + </em>. </span></p></div><div class="biblioentry"><a id="idp22956736"></a><p><span class="title"><em> <a class="link" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1976.html" target="_top"> Dynamic Shared Objects: Survey and Issues </a> </em>. </span><span class="subtitle"> ISO C++ J16/06-0046 - . </span><span class="author"><span class="firstname">Benjamin</span> <span class="surname">Kosnik</span>. </span></p></div><div class="biblioentry"><a id="idp22959456"></a><p><span class="title"><em> + . </span><span class="author"><span class="firstname">Benjamin</span> <span class="surname">Kosnik</span>. </span></p></div><div class="biblioentry"><a id="idp22960032"></a><p><span class="title"><em> <a class="link" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2013.html" target="_top"> Versioning With Namespaces </a> </em>. </span><span class="subtitle"> ISO C++ J16/06-0083 - . </span><span class="author"><span class="firstname">Benjamin</span> <span class="surname">Kosnik</span>. </span></p></div><div class="biblioentry"><a id="idp22962736"></a><p><span class="title"><em> + . </span><span class="author"><span class="firstname">Benjamin</span> <span class="surname">Kosnik</span>. </span></p></div><div class="biblioentry"><a id="idp22963312"></a><p><span class="title"><em> <a class="link" href="http://syrcose.ispras.ru/2009/files/SYRCoSE2009-CfP.pdf" target="_top"> Binary Compatibility of Shared Libraries Implemented in C++ on GNU/Linux Systems diff --git a/libstdc++-v3/doc/html/manual/algorithms.html b/libstdc++-v3/doc/html/manual/algorithms.html index 25f1628c73a..e02cc5b2a05 100644 --- a/libstdc++-v3/doc/html/manual/algorithms.html +++ b/libstdc++-v3/doc/html/manual/algorithms.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="numerics.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.algorithms"></a>Chapter 11. Algorithms - <a id="idp16191728" class="indexterm"></a> + <a id="idp16191968" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="algorithms.html#std.algorithms.mutating">Mutating</a></span></dt><dd><dl><dt><span class="section"><a href="algorithms.html#algorithms.mutating.swap"><code class="function">swap</code></a></span></dt><dd><dl><dt><span class="section"><a href="algorithms.html#algorithms.swap.specializations">Specializations</a></span></dt></dl></dd></dl></dd></dl></div><p> The neatest accomplishment of the algorithms section is that all the work is done via iterators, not containers directly. This means two diff --git a/libstdc++-v3/doc/html/manual/api.html b/libstdc++-v3/doc/html/manual/api.html index 6fe5d559362..c3538ad1884 100644 --- a/libstdc++-v3/doc/html/manual/api.html +++ b/libstdc++-v3/doc/html/manual/api.html @@ -77,11 +77,11 @@ _Alloc_traits</code> have been removed. <span class="type">__alloc</span> to select an underlying allocator that satisfied memory allocation requests. The selection of this underlying allocator was not user-configurable. - </p><div class="table"><a id="idp23029888"></a><p class="title"><strong>Table B.6. Extension Allocators</strong></p><div class="table-contents"><table summary="Extension Allocators" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Allocator (3.4)</th><th align="left">Header (3.4)</th><th align="left">Allocator (3.[0-3])</th><th align="left">Header (3.[0-3])</th></tr></thead><tbody><tr><td align="left"><code class="classname">__gnu_cxx::new_allocator<T></code></td><td align="left"><code class="filename">ext/new_allocator.h</code></td><td align="left"><code class="classname">std::__new_alloc</code></td><td align="left"><code class="filename">memory</code></td></tr><tr><td align="left"><code class="classname">__gnu_cxx::malloc_allocator<T></code></td><td align="left"><code class="filename">ext/malloc_allocator.h</code></td><td align="left"><code class="classname">std::__malloc_alloc_template<int></code></td><td align="left"><code class="filename">memory</code></td></tr><tr><td align="left"><code class="classname">__gnu_cxx::debug_allocator<T></code></td><td align="left"><code class="filename">ext/debug_allocator.h</code></td><td align="left"><code class="classname">std::debug_alloc<T></code></td><td align="left"><code class="filename">memory</code></td></tr><tr><td align="left"><code class="classname">__gnu_cxx::__pool_alloc<T></code></td><td align="left"><code class="filename">ext/pool_allocator.h</code></td><td align="left"><code class="classname">std::__default_alloc_template<bool,int></code></td><td align="left"><code class="filename">memory</code></td></tr><tr><td align="left"><code class="classname">__gnu_cxx::__mt_alloc<T></code></td><td align="left"><code class="filename">ext/mt_allocator.h</code></td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left"><code class="classname">__gnu_cxx::bitmap_allocator<T></code></td><td align="left"><code class="filename">ext/bitmap_allocator.h</code></td><td align="left"> </td><td align="left"> </td></tr></tbody></table></div></div><br class="table-break" /><p> Releases after gcc-3.4 have continued to add to the collection + </p><div class="table"><a id="idp23030528"></a><p class="title"><strong>Table B.6. Extension Allocators</strong></p><div class="table-contents"><table summary="Extension Allocators" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Allocator (3.4)</th><th align="left">Header (3.4)</th><th align="left">Allocator (3.[0-3])</th><th align="left">Header (3.[0-3])</th></tr></thead><tbody><tr><td align="left"><code class="classname">__gnu_cxx::new_allocator<T></code></td><td align="left"><code class="filename">ext/new_allocator.h</code></td><td align="left"><code class="classname">std::__new_alloc</code></td><td align="left"><code class="filename">memory</code></td></tr><tr><td align="left"><code class="classname">__gnu_cxx::malloc_allocator<T></code></td><td align="left"><code class="filename">ext/malloc_allocator.h</code></td><td align="left"><code class="classname">std::__malloc_alloc_template<int></code></td><td align="left"><code class="filename">memory</code></td></tr><tr><td align="left"><code class="classname">__gnu_cxx::debug_allocator<T></code></td><td align="left"><code class="filename">ext/debug_allocator.h</code></td><td align="left"><code class="classname">std::debug_alloc<T></code></td><td align="left"><code class="filename">memory</code></td></tr><tr><td align="left"><code class="classname">__gnu_cxx::__pool_alloc<T></code></td><td align="left"><code class="filename">ext/pool_allocator.h</code></td><td align="left"><code class="classname">std::__default_alloc_template<bool,int></code></td><td align="left"><code class="filename">memory</code></td></tr><tr><td align="left"><code class="classname">__gnu_cxx::__mt_alloc<T></code></td><td align="left"><code class="filename">ext/mt_allocator.h</code></td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left"><code class="classname">__gnu_cxx::bitmap_allocator<T></code></td><td align="left"><code class="filename">ext/bitmap_allocator.h</code></td><td align="left"> </td><td align="left"> </td></tr></tbody></table></div></div><br class="table-break" /><p> Releases after gcc-3.4 have continued to add to the collection of available allocators. All of these new allocators are standard-style. The following table includes details, along with the first released version of GCC that included the extension allocator. - </p><div class="table"><a id="idp23057520"></a><p class="title"><strong>Table B.7. Extension Allocators Continued</strong></p><div class="table-contents"><table summary="Extension Allocators Continued" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /></colgroup><thead><tr><th align="left">Allocator</th><th align="left">Include</th><th align="left">Version</th></tr></thead><tbody><tr><td align="left"><code class="classname">__gnu_cxx::array_allocator<T></code></td><td align="left"><code class="filename">ext/array_allocator.h</code></td><td align="left">4.0.0</td></tr><tr><td align="left"><code class="classname">__gnu_cxx::throw_allocator<T></code></td><td align="left"><code class="filename">ext/throw_allocator.h</code></td><td align="left">4.2.0</td></tr></tbody></table></div></div><br class="table-break" /><p> + </p><div class="table"><a id="idp23058160"></a><p class="title"><strong>Table B.7. Extension Allocators Continued</strong></p><div class="table-contents"><table summary="Extension Allocators Continued" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /></colgroup><thead><tr><th align="left">Allocator</th><th align="left">Include</th><th align="left">Version</th></tr></thead><tbody><tr><td align="left"><code class="classname">__gnu_cxx::array_allocator<T></code></td><td align="left"><code class="filename">ext/array_allocator.h</code></td><td align="left">4.0.0</td></tr><tr><td align="left"><code class="classname">__gnu_cxx::throw_allocator<T></code></td><td align="left"><code class="filename">ext/throw_allocator.h</code></td><td align="left">4.2.0</td></tr></tbody></table></div></div><br class="table-break" /><p> Debug mode first appears. </p><p> Precompiled header support <acronym class="acronym">PCH</acronym> support. diff --git a/libstdc++-v3/doc/html/manual/appendix_contributing.html b/libstdc++-v3/doc/html/manual/appendix_contributing.html index 6593938d552..108735a0d27 100644 --- a/libstdc++-v3/doc/html/manual/appendix_contributing.html +++ b/libstdc++-v3/doc/html/manual/appendix_contributing.html @@ -6,7 +6,7 @@ Appendices </th><td width="20%" align="right"> <a accesskey="n" href="source_organization.html">Next</a></td></tr></table><hr /></div><div class="appendix"><div class="titlepage"><div><div><h1 class="title"><a id="appendix.contrib"></a> Contributing - <a id="idp21874656" class="indexterm"></a> + <a id="idp21875168" class="indexterm"></a> </h1></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="appendix_contributing.html#contrib.list">Contributor Checklist</a></span></dt><dd><dl><dt><span class="section"><a href="appendix_contributing.html#list.reading">Reading</a></span></dt><dt><span class="section"><a href="appendix_contributing.html#list.copyright">Assignment</a></span></dt><dt><span class="section"><a href="appendix_contributing.html#list.getting">Getting Sources</a></span></dt><dt><span class="section"><a href="appendix_contributing.html#list.patches">Submitting Patches</a></span></dt></dl></dd><dt><span class="section"><a href="source_organization.html">Directory Layout and Source Conventions</a></span></dt><dt><span class="section"><a href="source_code_style.html">Coding Style</a></span></dt><dd><dl><dt><span class="section"><a href="source_code_style.html#coding_style.bad_identifiers">Bad Identifiers</a></span></dt><dt><span class="section"><a href="source_code_style.html#coding_style.example">By Example</a></span></dt></dl></dd><dt><span class="section"><a href="source_design_notes.html">Design Notes</a></span></dt></dl></div><p> The GNU C++ Library follows an open development model. Active contributors are assigned maintainer-ship responsibility, and given diff --git a/libstdc++-v3/doc/html/manual/appendix_free.html b/libstdc++-v3/doc/html/manual/appendix_free.html index aa44a4f203e..e57119c3e67 100644 --- a/libstdc++-v3/doc/html/manual/appendix_free.html +++ b/libstdc++-v3/doc/html/manual/appendix_free.html @@ -6,7 +6,7 @@ Appendices </th><td width="20%" align="right"> <a accesskey="n" href="appendix_gpl.html">Next</a></td></tr></table><hr /></div><div class="appendix"><div class="titlepage"><div><div><h1 class="title"><a id="appendix.free"></a> Free Software Needs Free Documentation - <a id="idp23425488" class="indexterm"></a> + <a id="idp23426192" class="indexterm"></a> </h1></div></div></div><p> The biggest deficiency in free operating systems is not in the software--it is the lack of good free manuals that we can include in diff --git a/libstdc++-v3/doc/html/manual/appendix_gpl.html b/libstdc++-v3/doc/html/manual/appendix_gpl.html index 204ac2b033d..f2f3caf67fb 100644 --- a/libstdc++-v3/doc/html/manual/appendix_gpl.html +++ b/libstdc++-v3/doc/html/manual/appendix_gpl.html @@ -77,7 +77,7 @@ </p><p> The precise terms and conditions for copying, distribution and modification follow. - </p><h2><a id="idp23465680"></a> + </p><h2><a id="idp23466384"></a> TERMS AND CONDITIONS </h2><h2><a id="gpl-3-definitions"></a> 0. Definitions. @@ -618,7 +618,7 @@ waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. - </p><h2><a id="idp23564608"></a> + </p><h2><a id="idp23565184"></a> END OF TERMS AND CONDITIONS </h2><h2><a id="HowToApply"></a> How to Apply These Terms to Your New Programs diff --git a/libstdc++-v3/doc/html/manual/appendix_porting.html b/libstdc++-v3/doc/html/manual/appendix_porting.html index 23611571299..4a07cf91295 100644 --- a/libstdc++-v3/doc/html/manual/appendix_porting.html +++ b/libstdc++-v3/doc/html/manual/appendix_porting.html @@ -6,7 +6,7 @@ Appendices </th><td width="20%" align="right"> <a accesskey="n" href="documentation_hacking.html">Next</a></td></tr></table><hr /></div><div class="appendix"><div class="titlepage"><div><div><h1 class="title"><a id="appendix.porting"></a> Porting and Maintenance - <a id="idp22008160" class="indexterm"></a> + <a id="idp22008864" class="indexterm"></a> </h1></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="appendix_porting.html#appendix.porting.build_hacking">Configure and Build Hacking</a></span></dt><dd><dl><dt><span class="section"><a href="appendix_porting.html#build_hacking.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="appendix_porting.html#build_hacking.overview">Overview</a></span></dt><dd><dl><dt><span class="section"><a href="appendix_porting.html#build_hacking.overview.basic">General Process</a></span></dt><dt><span class="section"><a href="appendix_porting.html#build_hacking.overview.map">What Comes from Where</a></span></dt></dl></dd><dt><span class="section"><a href="appendix_porting.html#build_hacking.configure">Configure</a></span></dt><dd><dl><dt><span class="section"><a href="appendix_porting.html#build_hacking.configure.scripts">Storing Information in non-AC files (like configure.host)</a></span></dt><dt><span class="section"><a href="appendix_porting.html#build_hacking.configure.conventions">Coding and Commenting Conventions</a></span></dt><dt><span class="section"><a href="appendix_porting.html#build_hacking.configure.acinclude">The acinclude.m4 layout</a></span></dt><dt><span class="section"><a href="appendix_porting.html#build_hacking.configure.enable"><code class="constant">GLIBCXX_ENABLE</code>, the <code class="literal">--enable</code> maker</a></span></dt></dl></dd><dt><span class="section"><a href="appendix_porting.html#build_hacking.make">Make</a></span></dt></dl></dd><dt><span class="section"><a href="documentation_hacking.html">Writing and Generating Documentation</a></span></dt><dd><dl><dt><span class="section"><a href="documentation_hacking.html#doc.intro">Introduction</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#doc.generation">Generating Documentation</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#doc.doxygen">Doxygen</a></span></dt><dd><dl><dt><span class="section"><a href="documentation_hacking.html#doxygen.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#doxygen.rules">Generating the Doxygen Files</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#doxygen.debug">Debugging Generation</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#doxygen.markup">Markup</a></span></dt></dl></dd><dt><span class="section"><a href="documentation_hacking.html#doc.docbook">Docbook</a></span></dt><dd><dl><dt><span class="section"><a href="documentation_hacking.html#docbook.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#docbook.rules">Generating the DocBook Files</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#docbook.debug">Debugging Generation</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#docbook.validation">Editing and Validation</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#docbook.examples">File Organization and Basics</a></span></dt><dt><span class="section"><a href="documentation_hacking.html#docbook.markup">Markup By Example</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="internals.html">Porting to New Hardware or Operating Systems</a></span></dt><dd><dl><dt><span class="section"><a href="internals.html#internals.os">Operating System</a></span></dt><dt><span class="section"><a href="internals.html#internals.cpu">CPU</a></span></dt><dt><span class="section"><a href="internals.html#internals.char_types">Character Types</a></span></dt><dt><span class="section"><a href="internals.html#internals.thread_safety">Thread Safety</a></span></dt><dt><span class="section"><a href="internals.html#internals.numeric_limits">Numeric Limits</a></span></dt><dt><span class="section"><a href="internals.html#internals.libtool">Libtool</a></span></dt></dl></dd><dt><span class="section"><a href="test.html">Test</a></span></dt><dd><dl><dt><span class="section"><a href="test.html#test.organization">Organization</a></span></dt><dd><dl><dt><span class="section"><a href="test.html#test.organization.layout">Directory Layout</a></span></dt><dt><span class="section"><a href="test.html#test.organization.naming">Naming Conventions</a></span></dt></dl></dd><dt><span class="section"><a href="test.html#test.run">Running the Testsuite</a></span></dt><dd><dl><dt><span class="section"><a href="test.html#test.run.basic">Basic</a></span></dt><dt><span class="section"><a href="test.html#test.run.variations">Variations</a></span></dt><dt><span class="section"><a href="test.html#test.run.permutations">Permutations</a></span></dt></dl></dd><dt><span class="section"><a href="test.html#test.new_tests">Writing a new test case</a></span></dt><dt><span class="section"><a href="test.html#test.harness">Test Harness and Utilities</a></span></dt><dd><dl><dt><span class="section"><a href="test.html#test.harness.dejagnu">Dejagnu Harness Details</a></span></dt><dt><span class="section"><a href="test.html#test.harness.utils">Utilities</a></span></dt></dl></dd><dt><span class="section"><a href="test.html#test.special">Special Topics</a></span></dt><dd><dl><dt><span class="section"><a href="test.html#test.exception.safety"> Qualifying Exception Safety Guarantees @@ -61,7 +61,7 @@ make all in the build directory starts the build process. The <code class="literal">all</code> target comes from the <code class="filename">Makefile</code> file, which is generated via <span class="command"><strong>configure</strong></span> from the <code class="filename">Makefile.in</code> file, which is in turn generated (via <span class="command"><strong>automake</strong></span>) from the file <code class="filename">Makefile.am</code>. -</p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="build_hacking.overview.map"></a>What Comes from Where</h4></div></div></div><div class="figure"><a id="idp22035008"></a><p class="title"><strong>Figure B.1. Configure and Build File Dependencies</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/confdeps.png" align="middle" alt="Dependency Graph for Configure and Build Files" /></div></div></div><br class="figure-break" /><p> +</p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="build_hacking.overview.map"></a>What Comes from Where</h4></div></div></div><div class="figure"><a id="idp22035648"></a><p class="title"><strong>Figure B.1. Configure and Build File Dependencies</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/confdeps.png" align="middle" alt="Dependency Graph for Configure and Build Files" /></div></div></div><br class="figure-break" /><p> Regenerate all generated files by using the command <code class="code">autoreconf</code> at the top level of the libstdc++ source directory. diff --git a/libstdc++-v3/doc/html/manual/atomics.html b/libstdc++-v3/doc/html/manual/atomics.html index 8aebc78e638..f16fd827841 100644 --- a/libstdc++-v3/doc/html/manual/atomics.html +++ b/libstdc++-v3/doc/html/manual/atomics.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="concurrency.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.atomics"></a>Chapter 14. Atomics - <a id="idp16390272" class="indexterm"></a> + <a id="idp16390640" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="atomics.html#std.atomics.api">API Reference</a></span></dt></dl></div><p> Facilities for atomic operations. </p><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.atomics.api"></a>API Reference</h2></div></div></div><p> diff --git a/libstdc++-v3/doc/html/manual/backwards.html b/libstdc++-v3/doc/html/manual/backwards.html index e6e934c5da5..d8e391360c7 100644 --- a/libstdc++-v3/doc/html/manual/backwards.html +++ b/libstdc++-v3/doc/html/manual/backwards.html @@ -940,15 +940,15 @@ AC_DEFUN([AC_HEADER_UNORDERED_SET], [ This is a change in behavior from older versions. Now, most <span class="type">iterator_type</span> typedefs in container classes are POD objects, not <span class="type">value_type</span> pointers. -</p></div></div><div class="bibliography"><div class="titlepage"><div><div><h3 class="title"><a id="backwards.biblio"></a>Bibliography</h3></div></div></div><div class="biblioentry"><a id="idp23414400"></a><p><span class="title"><em> +</p></div></div><div class="bibliography"><div class="titlepage"><div><div><h3 class="title"><a id="backwards.biblio"></a>Bibliography</h3></div></div></div><div class="biblioentry"><a id="idp23415104"></a><p><span class="title"><em> <a class="link" href="http://www.kegel.com/gcc/gcc4.html" target="_top"> Migrating to GCC 4.1 </a> - </em>. </span><span class="author"><span class="firstname">Dan</span> <span class="surname">Kegel</span>. </span></p></div><div class="biblioentry"><a id="idp23417184"></a><p><span class="title"><em> + </em>. </span><span class="author"><span class="firstname">Dan</span> <span class="surname">Kegel</span>. </span></p></div><div class="biblioentry"><a id="idp23417888"></a><p><span class="title"><em> <a class="link" href="http://lists.debian.org/debian-gcc/2006/03/msg00405.html" target="_top"> Building the Whole Debian Archive with GCC 4.1: A Summary </a> - </em>. </span><span class="author"><span class="firstname">Martin</span> <span class="surname">Michlmayr</span>. </span></p></div><div class="biblioentry"><a id="idp23420032"></a><p><span class="title"><em> + </em>. </span><span class="author"><span class="firstname">Martin</span> <span class="surname">Michlmayr</span>. </span></p></div><div class="biblioentry"><a id="idp23420736"></a><p><span class="title"><em> <a class="link" href="http://annwm.lbl.gov/~leggett/Atlas/gcc-3.2.html" target="_top"> Migration guide for GCC-3.2 </a> diff --git a/libstdc++-v3/doc/html/manual/bitmap_allocator_impl.html b/libstdc++-v3/doc/html/manual/bitmap_allocator_impl.html index 2afeebc8675..2f16969ab4d 100644 --- a/libstdc++-v3/doc/html/manual/bitmap_allocator_impl.html +++ b/libstdc++-v3/doc/html/manual/bitmap_allocator_impl.html @@ -75,7 +75,7 @@ else return false.</p></li></ol></div><p> </p><p> Consider a block of size 64 ints. In memory, it would look like this: (assume a 32-bit system where, size_t is a 32-bit entity). - </p><div class="table"><a id="idp17501232"></a><p class="title"><strong>Table 21.1. Bitmap Allocator Memory Map</strong></p><div class="table-contents"><table summary="Bitmap Allocator Memory Map" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left">268</td><td align="left">0</td><td align="left">4294967295</td><td align="left">4294967295</td><td align="left">Data -> Space for 64 ints</td></tr></tbody></table></div></div><br class="table-break" /><p> + </p><div class="table"><a id="idp17500848"></a><p class="title"><strong>Table 21.1. Bitmap Allocator Memory Map</strong></p><div class="table-contents"><table summary="Bitmap Allocator Memory Map" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left">268</td><td align="left">0</td><td align="left">4294967295</td><td align="left">4294967295</td><td align="left">Data -> Space for 64 ints</td></tr></tbody></table></div></div><br class="table-break" /><p> The first Column(268) represents the size of the Block in bytes as seen by the Bitmap Allocator. Internally, a global free list is used to keep track of the free blocks used and given back by the diff --git a/libstdc++-v3/doc/html/manual/concurrency.html b/libstdc++-v3/doc/html/manual/concurrency.html index caefd4738ee..22f5bac74e6 100644 --- a/libstdc++-v3/doc/html/manual/concurrency.html +++ b/libstdc++-v3/doc/html/manual/concurrency.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="extensions.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.concurrency"></a>Chapter 15. Concurrency - <a id="idp16404160" class="indexterm"></a> + <a id="idp16404464" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="concurrency.html#std.concurrency.api">API Reference</a></span></dt></dl></div><p> Facilities for concurrent operation, and control thereof. </p><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.concurrency.api"></a>API Reference</h2></div></div></div><p> diff --git a/libstdc++-v3/doc/html/manual/containers.html b/libstdc++-v3/doc/html/manual/containers.html index d3254d01918..4652eda446b 100644 --- a/libstdc++-v3/doc/html/manual/containers.html +++ b/libstdc++-v3/doc/html/manual/containers.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="associative.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.containers"></a>Chapter 9. Containers - <a id="idp16037648" class="indexterm"></a> + <a id="idp16037808" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="containers.html#std.containers.sequences">Sequences</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#containers.sequences.list">list</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#sequences.list.size">list::size() is O(n)</a></span></dt></dl></dd><dt><span class="section"><a href="containers.html#containers.sequences.vector">vector</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#sequences.vector.management">Space Overhead Management</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="associative.html">Associative</a></span></dt><dd><dl><dt><span class="section"><a href="associative.html#containers.associative.insert_hints">Insertion Hints</a></span></dt><dt><span class="section"><a href="associative.html#containers.associative.bitset">bitset</a></span></dt><dd><dl><dt><span class="section"><a href="associative.html#associative.bitset.size_variable">Size Variable</a></span></dt><dt><span class="section"><a href="associative.html#associative.bitset.type_string">Type String</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="unordered_associative.html">Unordered Associative</a></span></dt><dd><dl><dt><span class="section"><a href="unordered_associative.html#containers.unordered.hash">Hash Code</a></span></dt><dd><dl><dt><span class="section"><a href="unordered_associative.html#containers.unordered.cache">Hash Code Caching Policy</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="containers_and_c.html">Interacting with C</a></span></dt><dd><dl><dt><span class="section"><a href="containers_and_c.html#containers.c.vs_array">Containers vs. Arrays</a></span></dt></dl></dd></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.containers.sequences"></a>Sequences</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="containers.sequences.list"></a>list</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="sequences.list.size"></a>list::size() is O(n)</h4></div></div></div><p> Yes it is, and that's okay. This is a decision that we preserved when we imported SGI's STL implementation. The following is diff --git a/libstdc++-v3/doc/html/manual/debug_mode_using.html b/libstdc++-v3/doc/html/manual/debug_mode_using.html index f6ced5b1fd5..d9f7172f97f 100644 --- a/libstdc++-v3/doc/html/manual/debug_mode_using.html +++ b/libstdc++-v3/doc/html/manual/debug_mode_using.html @@ -18,6 +18,6 @@ mode or with debug mode. The following table provides the names and headers of the debugging containers: -</p><div class="table"><a id="idp16490080"></a><p class="title"><strong>Table 17.1. Debugging Containers</strong></p><div class="table-contents"><table summary="Debugging Containers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Container</th><th align="left">Header</th><th align="left">Debug container</th><th align="left">Debug header</th></tr></thead><tbody><tr><td align="left"><code class="classname">std::bitset</code></td><td align="left"><code class="filename">bitset</code></td><td align="left"><code class="classname">__gnu_debug::bitset</code></td><td align="left"><code class="filename"><debug/bitset></code></td></tr><tr><td align="left"><code class="classname">std::deque</code></td><td align="left"><code class="filename">deque</code></td><td align="left"><code class="classname">__gnu_debug::deque</code></td><td align="left"><code class="filename"><debug/deque></code></td></tr><tr><td align="left"><code class="classname">std::list</code></td><td align="left"><code class="filename">list</code></td><td align="left"><code class="classname">__gnu_debug::list</code></td><td align="left"><code class="filename"><debug/list></code></td></tr><tr><td align="left"><code class="classname">std::map</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="classname">__gnu_debug::map</code></td><td align="left"><code class="filename"><debug/map></code></td></tr><tr><td align="left"><code class="classname">std::multimap</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="classname">__gnu_debug::multimap</code></td><td align="left"><code class="filename"><debug/map></code></td></tr><tr><td align="left"><code class="classname">std::multiset</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="classname">__gnu_debug::multiset</code></td><td align="left"><code class="filename"><debug/set></code></td></tr><tr><td align="left"><code class="classname">std::set</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="classname">__gnu_debug::set</code></td><td align="left"><code class="filename"><debug/set></code></td></tr><tr><td align="left"><code class="classname">std::string</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::string</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::wstring</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::wstring</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::basic_string</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::basic_string</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::vector</code></td><td align="left"><code class="filename">vector</code></td><td align="left"><code class="classname">__gnu_debug::vector</code></td><td align="left"><code class="filename"><debug/vector></code></td></tr></tbody></table></div></div><br class="table-break" /><p>In addition, when compiling in C++11 mode, these additional +</p><div class="table"><a id="idp16490400"></a><p class="title"><strong>Table 17.1. Debugging Containers</strong></p><div class="table-contents"><table summary="Debugging Containers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Container</th><th align="left">Header</th><th align="left">Debug container</th><th align="left">Debug header</th></tr></thead><tbody><tr><td align="left"><code class="classname">std::bitset</code></td><td align="left"><code class="filename">bitset</code></td><td align="left"><code class="classname">__gnu_debug::bitset</code></td><td align="left"><code class="filename"><debug/bitset></code></td></tr><tr><td align="left"><code class="classname">std::deque</code></td><td align="left"><code class="filename">deque</code></td><td align="left"><code class="classname">__gnu_debug::deque</code></td><td align="left"><code class="filename"><debug/deque></code></td></tr><tr><td align="left"><code class="classname">std::list</code></td><td align="left"><code class="filename">list</code></td><td align="left"><code class="classname">__gnu_debug::list</code></td><td align="left"><code class="filename"><debug/list></code></td></tr><tr><td align="left"><code class="classname">std::map</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="classname">__gnu_debug::map</code></td><td align="left"><code class="filename"><debug/map></code></td></tr><tr><td align="left"><code class="classname">std::multimap</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="classname">__gnu_debug::multimap</code></td><td align="left"><code class="filename"><debug/map></code></td></tr><tr><td align="left"><code class="classname">std::multiset</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="classname">__gnu_debug::multiset</code></td><td align="left"><code class="filename"><debug/set></code></td></tr><tr><td align="left"><code class="classname">std::set</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="classname">__gnu_debug::set</code></td><td align="left"><code class="filename"><debug/set></code></td></tr><tr><td align="left"><code class="classname">std::string</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::string</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::wstring</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::wstring</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::basic_string</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="classname">__gnu_debug::basic_string</code></td><td align="left"><code class="filename"><debug/string></code></td></tr><tr><td align="left"><code class="classname">std::vector</code></td><td align="left"><code class="filename">vector</code></td><td align="left"><code class="classname">__gnu_debug::vector</code></td><td align="left"><code class="filename"><debug/vector></code></td></tr></tbody></table></div></div><br class="table-break" /><p>In addition, when compiling in C++11 mode, these additional containers have additional debug capability. -</p><div class="table"><a id="idp16534976"></a><p class="title"><strong>Table 17.2. Debugging Containers C++11</strong></p><div class="table-contents"><table summary="Debugging Containers C++11" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Container</th><th align="left">Header</th><th align="left">Debug container</th><th align="left">Debug header</th></tr></thead><tbody><tr><td align="left"><code class="classname">std::unordered_map</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="classname">__gnu_debug::unordered_map</code></td><td align="left"><code class="filename"><debug/unordered_map></code></td></tr><tr><td align="left"><code class="classname">std::unordered_multimap</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="classname">__gnu_debug::unordered_multimap</code></td><td align="left"><code class="filename"><debug/unordered_map></code></td></tr><tr><td align="left"><code class="classname">std::unordered_set</code></td><td align="left"><code class="filename">unordered_set</code></td><td align="left"><code class="classname">__gnu_debug::unordered_set</code></td><td align="left"><code class="filename"><debug/unordered_set></code></td></tr><tr><td align="left"><code class="classname">std::unordered_multiset</code></td><td align="left"><code class="filename">unordered_set</code></td><td align="left"><code class="classname">__gnu_debug::unordered_multiset</code></td><td align="left"><code class="filename"><debug/unordered_set></code></td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="debug_mode_semantics.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="debug_mode.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="debug_mode_design.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Semantics </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Design</td></tr></table></div></body></html>
\ No newline at end of file +</p><div class="table"><a id="idp16535296"></a><p class="title"><strong>Table 17.2. Debugging Containers C++11</strong></p><div class="table-contents"><table summary="Debugging Containers C++11" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Container</th><th align="left">Header</th><th align="left">Debug container</th><th align="left">Debug header</th></tr></thead><tbody><tr><td align="left"><code class="classname">std::unordered_map</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="classname">__gnu_debug::unordered_map</code></td><td align="left"><code class="filename"><debug/unordered_map></code></td></tr><tr><td align="left"><code class="classname">std::unordered_multimap</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="classname">__gnu_debug::unordered_multimap</code></td><td align="left"><code class="filename"><debug/unordered_map></code></td></tr><tr><td align="left"><code class="classname">std::unordered_set</code></td><td align="left"><code class="filename">unordered_set</code></td><td align="left"><code class="classname">__gnu_debug::unordered_set</code></td><td align="left"><code class="filename"><debug/unordered_set></code></td></tr><tr><td align="left"><code class="classname">std::unordered_multiset</code></td><td align="left"><code class="filename">unordered_set</code></td><td align="left"><code class="classname">__gnu_debug::unordered_multiset</code></td><td align="left"><code class="filename"><debug/unordered_set></code></td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="debug_mode_semantics.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="debug_mode.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="debug_mode_design.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Semantics </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Design</td></tr></table></div></body></html>
\ No newline at end of file diff --git a/libstdc++-v3/doc/html/manual/diagnostics.html b/libstdc++-v3/doc/html/manual/diagnostics.html index 539e8e2ed1c..82c58e6f551 100644 --- a/libstdc++-v3/doc/html/manual/diagnostics.html +++ b/libstdc++-v3/doc/html/manual/diagnostics.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="concept_checking.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.diagnostics"></a>Chapter 5. Diagnostics - <a id="idp13833200" class="indexterm"></a> + <a id="idp13835248" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions">Exceptions</a></span></dt><dd><dl><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions.api">API Reference</a></span></dt><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions.data">Adding Data to <code class="classname">exception</code></a></span></dt></dl></dd><dt><span class="section"><a href="concept_checking.html">Concept Checking</a></span></dt></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.diagnostics.exceptions"></a>Exceptions</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="std.diagnostics.exceptions.api"></a>API Reference</h3></div></div></div><p> All exception objects are defined in one of the standard header files: <code class="filename">exception</code>, diff --git a/libstdc++-v3/doc/html/manual/documentation_hacking.html b/libstdc++-v3/doc/html/manual/documentation_hacking.html index cd5f18e7c5a..e84c8fd49ec 100644 --- a/libstdc++-v3/doc/html/manual/documentation_hacking.html +++ b/libstdc++-v3/doc/html/manual/documentation_hacking.html @@ -112,7 +112,7 @@ supported, and are always aliased to dummy rules. These unsupported formats are: <span class="emphasis"><em>info</em></span>, <span class="emphasis"><em>ps</em></span>, and <span class="emphasis"><em>dvi</em></span>. - </p></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="doc.doxygen"></a>Doxygen</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="doxygen.prereq"></a>Prerequisites</h4></div></div></div><div class="table"><a id="idp22161856"></a><p class="title"><strong>Table B.1. Doxygen Prerequisites</strong></p><div class="table-contents"><table summary="Doxygen Prerequisites" border="1"><colgroup><col align="center" class="c1" /><col align="center" class="c2" /><col align="center" class="c3" /></colgroup><thead><tr><th align="center">Tool</th><th align="center">Version</th><th align="center">Required By</th></tr></thead><tbody><tr><td align="center">coreutils</td><td align="center">8.5</td><td align="center">all</td></tr><tr><td align="center">bash</td><td align="center">4.1</td><td align="center">all</td></tr><tr><td align="center">doxygen</td><td align="center">1.7.6.1</td><td align="center">all</td></tr><tr><td align="center">graphviz</td><td align="center">2.26</td><td align="center">graphical hierarchies</td></tr><tr><td align="center">pdflatex</td><td align="center">2007-59</td><td align="center">pdf output</td></tr></tbody></table></div></div><br class="table-break" /><p> + </p></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="doc.doxygen"></a>Doxygen</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="doxygen.prereq"></a>Prerequisites</h4></div></div></div><div class="table"><a id="idp22162432"></a><p class="title"><strong>Table B.1. Doxygen Prerequisites</strong></p><div class="table-contents"><table summary="Doxygen Prerequisites" border="1"><colgroup><col align="center" class="c1" /><col align="center" class="c2" /><col align="center" class="c3" /></colgroup><thead><tr><th align="center">Tool</th><th align="center">Version</th><th align="center">Required By</th></tr></thead><tbody><tr><td align="center">coreutils</td><td align="center">8.5</td><td align="center">all</td></tr><tr><td align="center">bash</td><td align="center">4.1</td><td align="center">all</td></tr><tr><td align="center">doxygen</td><td align="center">1.7.6.1</td><td align="center">all</td></tr><tr><td align="center">graphviz</td><td align="center">2.26</td><td align="center">graphical hierarchies</td></tr><tr><td align="center">pdflatex</td><td align="center">2007-59</td><td align="center">pdf output</td></tr></tbody></table></div></div><br class="table-break" /><p> Prerequisite tools are Bash 2.0 or later, <a class="link" href="http://www.doxygen.org/" target="_top">Doxygen</a>, and the <a class="link" href="http://www.gnu.org/software/coreutils/" target="_top">GNU @@ -310,7 +310,7 @@ writing Doxygen comments. Single and double quotes, and separators in filenames are two common trouble spots. When in doubt, consult the following table. - </p><div class="table"><a id="idp22237520"></a><p class="title"><strong>Table B.2. HTML to Doxygen Markup Comparison</strong></p><div class="table-contents"><table summary="HTML to Doxygen Markup Comparison" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">HTML</th><th align="left">Doxygen</th></tr></thead><tbody><tr><td align="left">\</td><td align="left">\\</td></tr><tr><td align="left">"</td><td align="left">\"</td></tr><tr><td align="left">'</td><td align="left">\'</td></tr><tr><td align="left"><i></td><td align="left">@a word</td></tr><tr><td align="left"><b></td><td align="left">@b word</td></tr><tr><td align="left"><code></td><td align="left">@c word</td></tr><tr><td align="left"><em></td><td align="left">@a word</td></tr><tr><td align="left"><em></td><td align="left"><em>two words or more</em></td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="doc.docbook"></a>Docbook</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="docbook.prereq"></a>Prerequisites</h4></div></div></div><div class="table"><a id="idp22256960"></a><p class="title"><strong>Table B.3. Docbook Prerequisites</strong></p><div class="table-contents"><table summary="Docbook Prerequisites" border="1"><colgroup><col align="center" class="c1" /><col align="center" class="c2" /><col align="center" class="c3" /></colgroup><thead><tr><th align="center">Tool</th><th align="center">Version</th><th align="center">Required By</th></tr></thead><tbody><tr><td align="center">docbook5-style-xsl</td><td align="center">1.76.1</td><td align="center">all</td></tr><tr><td align="center">xsltproc</td><td align="center">1.1.26</td><td align="center">all</td></tr><tr><td align="center">xmllint</td><td align="center">2.7.7</td><td align="center">validation</td></tr><tr><td align="center">dblatex</td><td align="center">0.3</td><td align="center">pdf output</td></tr><tr><td align="center">pdflatex</td><td align="center">2007-59</td><td align="center">pdf output</td></tr><tr><td align="center">docbook2X</td><td align="center">0.8.8</td><td align="center">info output</td></tr><tr><td align="center">epub3 stylesheets</td><td align="center">b3</td><td align="center">epub output</td></tr></tbody></table></div></div><br class="table-break" /><p> + </p><div class="table"><a id="idp22238096"></a><p class="title"><strong>Table B.2. HTML to Doxygen Markup Comparison</strong></p><div class="table-contents"><table summary="HTML to Doxygen Markup Comparison" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">HTML</th><th align="left">Doxygen</th></tr></thead><tbody><tr><td align="left">\</td><td align="left">\\</td></tr><tr><td align="left">"</td><td align="left">\"</td></tr><tr><td align="left">'</td><td align="left">\'</td></tr><tr><td align="left"><i></td><td align="left">@a word</td></tr><tr><td align="left"><b></td><td align="left">@b word</td></tr><tr><td align="left"><code></td><td align="left">@c word</td></tr><tr><td align="left"><em></td><td align="left">@a word</td></tr><tr><td align="left"><em></td><td align="left"><em>two words or more</em></td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="doc.docbook"></a>Docbook</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="docbook.prereq"></a>Prerequisites</h4></div></div></div><div class="table"><a id="idp22257536"></a><p class="title"><strong>Table B.3. Docbook Prerequisites</strong></p><div class="table-contents"><table summary="Docbook Prerequisites" border="1"><colgroup><col align="center" class="c1" /><col align="center" class="c2" /><col align="center" class="c3" /></colgroup><thead><tr><th align="center">Tool</th><th align="center">Version</th><th align="center">Required By</th></tr></thead><tbody><tr><td align="center">docbook5-style-xsl</td><td align="center">1.76.1</td><td align="center">all</td></tr><tr><td align="center">xsltproc</td><td align="center">1.1.26</td><td align="center">all</td></tr><tr><td align="center">xmllint</td><td align="center">2.7.7</td><td align="center">validation</td></tr><tr><td align="center">dblatex</td><td align="center">0.3</td><td align="center">pdf output</td></tr><tr><td align="center">pdflatex</td><td align="center">2007-59</td><td align="center">pdf output</td></tr><tr><td align="center">docbook2X</td><td align="center">0.8.8</td><td align="center">info output</td></tr><tr><td align="center">epub3 stylesheets</td><td align="center">b3</td><td align="center">epub output</td></tr></tbody></table></div></div><br class="table-break" /><p> Editing the DocBook sources requires an XML editor. Many exist: some notable options include <span class="command"><strong>emacs</strong></span>, <span class="application">Kate</span>, @@ -520,11 +520,11 @@ make <code class="literal">XSL_STYLE_DIR="/usr/share/xml/docbook/stylesheet/nwal <a class="link" href="http://www.docbook.org/tdg/en/html/part2.html" target="_top">online</a>. An incomplete reference for HTML to Docbook conversion is detailed in the table below. - </p><div class="table"><a id="idp22334528"></a><p class="title"><strong>Table B.4. HTML to Docbook XML Markup Comparison</strong></p><div class="table-contents"><table summary="HTML to Docbook XML Markup Comparison" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">HTML</th><th align="left">Docbook</th></tr></thead><tbody><tr><td align="left"><p></td><td align="left"><para></td></tr><tr><td align="left"><pre></td><td align="left"><computeroutput>, <programlisting>, + </p><div class="table"><a id="idp22335040"></a><p class="title"><strong>Table B.4. HTML to Docbook XML Markup Comparison</strong></p><div class="table-contents"><table summary="HTML to Docbook XML Markup Comparison" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">HTML</th><th align="left">Docbook</th></tr></thead><tbody><tr><td align="left"><p></td><td align="left"><para></td></tr><tr><td align="left"><pre></td><td align="left"><computeroutput>, <programlisting>, <literallayout></td></tr><tr><td align="left"><ul></td><td align="left"><itemizedlist></td></tr><tr><td align="left"><ol></td><td align="left"><orderedlist></td></tr><tr><td align="left"><il></td><td align="left"><listitem></td></tr><tr><td align="left"><dl></td><td align="left"><variablelist></td></tr><tr><td align="left"><dt></td><td align="left"><term></td></tr><tr><td align="left"><dd></td><td align="left"><listitem></td></tr><tr><td align="left"><a href=""></td><td align="left"><ulink url=""></td></tr><tr><td align="left"><code></td><td align="left"><literal>, <programlisting></td></tr><tr><td align="left"><strong></td><td align="left"><emphasis></td></tr><tr><td align="left"><em></td><td align="left"><emphasis></td></tr><tr><td align="left">"</td><td align="left"><quote></td></tr></tbody></table></div></div><br class="table-break" /><p> And examples of detailed markup for which there are no real HTML equivalents are listed in the table below. -</p><div class="table"><a id="idp22358672"></a><p class="title"><strong>Table B.5. Docbook XML Element Use</strong></p><div class="table-contents"><table summary="Docbook XML Element Use" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">Element</th><th align="left">Use</th></tr></thead><tbody><tr><td align="left"><structname></td><td align="left"><structname>char_traits</structname></td></tr><tr><td align="left"><classname></td><td align="left"><classname>string</classname></td></tr><tr><td align="left"><function></td><td align="left"> +</p><div class="table"><a id="idp22359184"></a><p class="title"><strong>Table B.5. Docbook XML Element Use</strong></p><div class="table-contents"><table summary="Docbook XML Element Use" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">Element</th><th align="left">Use</th></tr></thead><tbody><tr><td align="left"><structname></td><td align="left"><structname>char_traits</structname></td></tr><tr><td align="left"><classname></td><td align="left"><classname>string</classname></td></tr><tr><td align="left"><function></td><td align="left"> <p><function>clear()</function></p> <p><function>fs.clear()</function></p> </td></tr><tr><td align="left"><type></td><td align="left"><type>long long</type></td></tr><tr><td align="left"><varname></td><td align="left"><varname>fs</varname></td></tr><tr><td align="left"><literal></td><td align="left"> diff --git a/libstdc++-v3/doc/html/manual/ext_preface.html b/libstdc++-v3/doc/html/manual/ext_preface.html index 83f54793cb8..851a3d80476 100644 --- a/libstdc++-v3/doc/html/manual/ext_preface.html +++ b/libstdc++-v3/doc/html/manual/ext_preface.html @@ -2,7 +2,7 @@ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title></title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.77.1" /><meta name="keywords" content="ISO C++, library" /><meta name="keywords" content="ISO C++, runtime, library" /><link rel="home" href="../index.html" title="The GNU C++ Library" /><link rel="up" href="extensions.html" title="Part III. Extensions" /><link rel="prev" href="extensions.html" title="Part III. Extensions" /><link rel="next" href="ext_compile_checks.html" title="Chapter 16. Compile Time Checks" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center"></th></tr><tr><td width="20%" align="left"><a accesskey="p" href="extensions.html">Prev</a> </td><th width="60%" align="center">Part III. Extensions -</th><td width="20%" align="right"> <a accesskey="n" href="ext_compile_checks.html">Next</a></td></tr></table><hr /></div><div class="preface"><div class="titlepage"><div><div><h1 class="title"><a id="idp16425680"></a></h1></div></div></div><p> +</th><td width="20%" align="right"> <a accesskey="n" href="ext_compile_checks.html">Next</a></td></tr></table><hr /></div><div class="preface"><div class="titlepage"><div><div><h1 class="title"><a id="idp16425920"></a></h1></div></div></div><p> Here we will make an attempt at describing the non-Standard extensions to the library. Some of these are from older versions of standard library components, namely SGI's STL, and some of these are diff --git a/libstdc++-v3/doc/html/manual/extensions.html b/libstdc++-v3/doc/html/manual/extensions.html index 41aceae972c..93540a694c4 100644 --- a/libstdc++-v3/doc/html/manual/extensions.html +++ b/libstdc++-v3/doc/html/manual/extensions.html @@ -4,7 +4,7 @@ </th></tr><tr><td width="20%" align="left"><a accesskey="p" href="io_and_c.html">Prev</a> </td><th width="60%" align="center">The GNU C++ Library Manual</th><td width="20%" align="right"> <a accesskey="n" href="ext_preface.html">Next</a></td></tr></table><hr /></div><div class="part"><div class="titlepage"><div><div><h1 class="title"><a id="manual.ext"></a>Part III. Extensions - <a id="idp16423440" class="indexterm"></a> + <a id="idp16423680" class="indexterm"></a> </h1></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="preface"><a href="ext_preface.html"></a></span></dt><dt><span class="chapter"><a href="ext_compile_checks.html">16. Compile Time Checks</a></span></dt><dt><span class="chapter"><a href="debug_mode.html">17. Debug Mode</a></span></dt><dd><dl><dt><span class="section"><a href="debug_mode.html#manual.ext.debug_mode.intro">Intro</a></span></dt><dt><span class="section"><a href="debug_mode_semantics.html">Semantics</a></span></dt><dt><span class="section"><a href="debug_mode_using.html">Using</a></span></dt><dd><dl><dt><span class="section"><a href="debug_mode_using.html#debug_mode.using.mode">Using the Debug Mode</a></span></dt><dt><span class="section"><a href="debug_mode_using.html#debug_mode.using.specific">Using a Specific Debug Container</a></span></dt></dl></dd><dt><span class="section"><a href="debug_mode_design.html">Design</a></span></dt><dd><dl><dt><span class="section"><a href="debug_mode_design.html#debug_mode.design.goals">Goals</a></span></dt><dt><span class="section"><a href="debug_mode_design.html#debug_mode.design.methods">Methods</a></span></dt><dd><dl><dt><span class="section"><a href="debug_mode_design.html#debug_mode.design.methods.wrappers">The Wrapper Model</a></span></dt><dd><dl><dt><span class="section"><a href="debug_mode_design.html#debug_mode.design.methods.safe_iter">Safe Iterators</a></span></dt><dt><span class="section"><a href="debug_mode_design.html#debug_mode.design.methods.safe_seq">Safe Sequences (Containers)</a></span></dt></dl></dd><dt><span class="section"><a href="debug_mode_design.html#debug_mode.design.methods.precond">Precondition Checking</a></span></dt><dt><span class="section"><a href="debug_mode_design.html#debug_mode.design.methods.coexistence">Release- and debug-mode coexistence</a></span></dt><dd><dl><dt><span class="section"><a href="debug_mode_design.html#methods.coexistence.compile">Compile-time coexistence of release- and debug-mode components</a></span></dt><dt><span class="section"><a href="debug_mode_design.html#methods.coexistence.link">Link- and run-time coexistence of release- and debug-mode components</a></span></dt><dt><span class="section"><a href="debug_mode_design.html#methods.coexistence.alt">Alternatives for Coexistence</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="debug_mode_design.html#debug_mode.design.other">Other Implementations</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="parallel_mode.html">18. Parallel Mode</a></span></dt><dd><dl><dt><span class="section"><a href="parallel_mode.html#manual.ext.parallel_mode.intro">Intro</a></span></dt><dt><span class="section"><a href="parallel_mode_semantics.html">Semantics</a></span></dt><dt><span class="section"><a href="parallel_mode_using.html">Using</a></span></dt><dd><dl><dt><span class="section"><a href="parallel_mode_using.html#parallel_mode.using.prereq_flags">Prerequisite Compiler Flags</a></span></dt><dt><span class="section"><a href="parallel_mode_using.html#parallel_mode.using.parallel_mode">Using Parallel Mode</a></span></dt><dt><span class="section"><a href="parallel_mode_using.html#parallel_mode.using.specific">Using Specific Parallel Components</a></span></dt></dl></dd><dt><span class="section"><a href="parallel_mode_design.html">Design</a></span></dt><dd><dl><dt><span class="section"><a href="parallel_mode_design.html#parallel_mode.design.intro">Interface Basics</a></span></dt><dt><span class="section"><a href="parallel_mode_design.html#parallel_mode.design.tuning">Configuration and Tuning</a></span></dt><dd><dl><dt><span class="section"><a href="parallel_mode_design.html#parallel_mode.design.tuning.omp">Setting up the OpenMP Environment</a></span></dt><dt><span class="section"><a href="parallel_mode_design.html#parallel_mode.design.tuning.compile">Compile Time Switches</a></span></dt><dt><span class="section"><a href="parallel_mode_design.html#parallel_mode.design.tuning.settings">Run Time Settings and Defaults</a></span></dt></dl></dd><dt><span class="section"><a href="parallel_mode_design.html#parallel_mode.design.impl">Implementation Namespaces</a></span></dt></dl></dd><dt><span class="section"><a href="parallel_mode_test.html">Testing</a></span></dt><dt><span class="bibliography"><a href="parallel_mode.html#parallel_mode.biblio">Bibliography</a></span></dt></dl></dd><dt><span class="chapter"><a href="profile_mode.html">19. Profile Mode</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode.html#manual.ext.profile_mode.intro">Intro</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode.html#manual.ext.profile_mode.using">Using the Profile Mode</a></span></dt><dt><span class="section"><a href="profile_mode.html#manual.ext.profile_mode.tuning">Tuning the Profile Mode</a></span></dt></dl></dd><dt><span class="section"><a href="profile_mode_design.html">Design</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode_design.html#manual.ext.profile_mode.design.wrapper">Wrapper Model</a></span></dt><dt><span class="section"><a href="profile_mode_design.html#manual.ext.profile_mode.design.instrumentation">Instrumentation</a></span></dt><dt><span class="section"><a href="profile_mode_design.html#manual.ext.profile_mode.design.rtlib">Run Time Behavior</a></span></dt><dt><span class="section"><a href="profile_mode_design.html#manual.ext.profile_mode.design.analysis">Analysis and Diagnostics</a></span></dt><dt><span class="section"><a href="profile_mode_design.html#manual.ext.profile_mode.design.cost-model">Cost Model</a></span></dt><dt><span class="section"><a href="profile_mode_design.html#manual.ext.profile_mode.design.reports">Reports</a></span></dt><dt><span class="section"><a href="profile_mode_design.html#manual.ext.profile_mode.design.testing">Testing</a></span></dt></dl></dd><dt><span class="section"><a href="profile_mode_api.html">Extensions for Custom Containers</a></span></dt><dt><span class="section"><a href="profile_mode_cost_model.html">Empirical Cost Model</a></span></dt><dt><span class="section"><a href="profile_mode_impl.html">Implementation Issues</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode_impl.html#manual.ext.profile_mode.implementation.stack">Stack Traces</a></span></dt><dt><span class="section"><a href="profile_mode_impl.html#manual.ext.profile_mode.implementation.symbols">Symbolization of Instruction Addresses</a></span></dt><dt><span class="section"><a href="profile_mode_impl.html#manual.ext.profile_mode.implementation.concurrency">Concurrency</a></span></dt><dt><span class="section"><a href="profile_mode_impl.html#manual.ext.profile_mode.implementation.stdlib-in-proflib">Using the Standard Library in the Instrumentation Implementation</a></span></dt><dt><span class="section"><a href="profile_mode_impl.html#manual.ext.profile_mode.implementation.malloc-hooks">Malloc Hooks</a></span></dt><dt><span class="section"><a href="profile_mode_impl.html#manual.ext.profile_mode.implementation.construction-destruction">Construction and Destruction of Global Objects</a></span></dt></dl></dd><dt><span class="section"><a href="profile_mode_devel.html">Developer Information</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode_devel.html#manual.ext.profile_mode.developer.bigpic">Big Picture</a></span></dt><dt><span class="section"><a href="profile_mode_devel.html#manual.ext.profile_mode.developer.howto">How To Add A Diagnostic</a></span></dt></dl></dd><dt><span class="section"><a href="profile_mode_diagnostics.html">Diagnostics</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.template">Diagnostic Template</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.containers">Containers</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.hashtable_too_small">Hashtable Too Small</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.hashtable_too_large">Hashtable Too Large</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.inefficient_hash">Inefficient Hash</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.vector_too_small">Vector Too Small</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.vector_too_large">Vector Too Large</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.vector_to_hashtable">Vector to Hashtable</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.hashtable_to_vector">Hashtable to Vector</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.vector_to_list">Vector to List</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.list_to_vector">List to Vector</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.list_to_slist">List to Forward List (Slist)</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.assoc_ord_to_unord">Ordered to Unordered Associative Container</a></span></dt></dl></dd><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.algorithms">Algorithms</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.algorithms.sort">Sort Algorithm Performance</a></span></dt></dl></dd><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.locality">Data Locality</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.locality.sw_prefetch">Need Software Prefetch</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.locality.linked">Linked Structure Locality</a></span></dt></dl></dd><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.mthread">Multithreaded Data Access</a></span></dt><dd><dl><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.mthread.ddtest">Data Dependence Violations at Container Level</a></span></dt><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.mthread.false_share">False Sharing</a></span></dt></dl></dd><dt><span class="section"><a href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.statistics">Statistics</a></span></dt></dl></dd><dt><span class="bibliography"><a href="profile_mode.html#profile_mode.biblio">Bibliography</a></span></dt></dl></dd><dt><span class="chapter"><a href="mt_allocator.html">20. The mt_allocator</a></span></dt><dd><dl><dt><span class="section"><a href="mt_allocator.html#allocator.mt.intro">Intro</a></span></dt><dt><span class="section"><a href="mt_allocator_design.html">Design Issues</a></span></dt><dd><dl><dt><span class="section"><a href="mt_allocator_design.html#allocator.mt.overview">Overview</a></span></dt></dl></dd><dt><span class="section"><a href="mt_allocator_impl.html">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="mt_allocator_impl.html#allocator.mt.tune">Tunable Parameters</a></span></dt><dt><span class="section"><a href="mt_allocator_impl.html#allocator.mt.init">Initialization</a></span></dt><dt><span class="section"><a href="mt_allocator_impl.html#allocator.mt.deallocation">Deallocation Notes</a></span></dt></dl></dd><dt><span class="section"><a href="mt_allocator_ex_single.html">Single Thread Example</a></span></dt><dt><span class="section"><a href="mt_allocator_ex_multi.html">Multiple Thread Example</a></span></dt></dl></dd><dt><span class="chapter"><a href="bitmap_allocator.html">21. The bitmap_allocator</a></span></dt><dd><dl><dt><span class="section"><a href="bitmap_allocator.html#allocator.bitmap.design">Design</a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.free_list_store">Free List Store</a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.super_block">Super Block</a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.super_block_data">Super Block Data Layout</a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.max_wasted">Maximum Wasted Percentage</a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.allocate"><code class="function">allocate</code></a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.deallocate"><code class="function">deallocate</code></a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.questions">Questions</a></span></dt><dd><dl><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.question.1">1</a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.question.2">2</a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.question.3">3</a></span></dt></dl></dd><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.locality">Locality</a></span></dt><dt><span class="section"><a href="bitmap_allocator_impl.html#bitmap.impl.grow_policy">Overhead and Grow Policy</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="policy_data_structures.html">22. Policy-Based Data Structures</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#pbds.intro">Intro</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.issues">Performance Issues</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.issues.associative">Associative</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.issues.priority_queue">Priority Que</a></span></dt></dl></dd><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.motivation">Goals</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.motivation.associative">Associative</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#motivation.associative.policy">Policy Choices</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.associative.underlying">Underlying Data Structures</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.associative.iterators">Iterators</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.associative.functions">Functional</a></span></dt></dl></dd><dt><span class="section"><a href="policy_data_structures.html#pbds.intro.motivation.priority_queue">Priority Queues</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures.html#motivation.priority_queue.policy">Policy Choices</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.priority_queue.underlying">Underlying Data Structures</a></span></dt><dt><span class="section"><a href="policy_data_structures.html#motivation.priority_queue.binary_heap">Binary Heaps</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="section"><a href="policy_data_structures_using.html">Using</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.organization">Organization</a></span></dt><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.tutorial">Tutorial</a></span></dt><dd><dl><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.tutorial.basic">Basic Use</a></span></dt><dt><span class="section"><a href="policy_data_structures_using.html#pbds.using.tutorial.configuring"> Configuring via Template Parameters diff --git a/libstdc++-v3/doc/html/manual/facets.html b/libstdc++-v3/doc/html/manual/facets.html index 4ad2840f1bc..7d98192c72d 100644 --- a/libstdc++-v3/doc/html/manual/facets.html +++ b/libstdc++-v3/doc/html/manual/facets.html @@ -2,7 +2,7 @@ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Facets</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.77.1" /><meta name="keywords" content="ISO C++, library" /><meta name="keywords" content="ISO C++, runtime, library" /><link rel="home" href="../index.html" title="The GNU C++ Library" /><link rel="up" href="localization.html" title="Chapter 8. Localization" /><link rel="prev" href="localization.html" title="Chapter 8. Localization" /><link rel="next" href="containers.html" title="Chapter 9. Containers" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Facets</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="localization.html">Prev</a> </td><th width="60%" align="center">Chapter 8. Localization -</th><td width="20%" align="right"> <a accesskey="n" href="containers.html">Next</a></td></tr></table><hr /></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.localization.facet"></a>Facets</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="std.localization.facet.ctype"></a>ctype</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="facet.ctype.impl"></a>Implementation</h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15777920"></a>Specializations</h5></div></div></div><p> +</th><td width="20%" align="right"> <a accesskey="n" href="containers.html">Next</a></td></tr></table><hr /></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.localization.facet"></a>Facets</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="std.localization.facet.ctype"></a>ctype</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="facet.ctype.impl"></a>Implementation</h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15778336"></a>Specializations</h5></div></div></div><p> For the required specialization codecvt<wchar_t, char, mbstate_t> , conversions are made between the internal character set (always UCS4 on GNU/Linux) and whatever the currently selected locale for the @@ -49,24 +49,24 @@ characters. </p></li><li class="listitem"><p> Rename abstract base class. See if just smash-overriding is a better approach. Clarify, add sanity to naming. - </p></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="facet.ctype.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp15793040"></a><p><span class="citetitle"><em class="citetitle"> + </p></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="facet.ctype.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp15793392"></a><p><span class="citetitle"><em class="citetitle"> The GNU C Library - </em>. </span><span class="author"><span class="firstname">Roland</span> <span class="surname">McGrath</span>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2007 FSF. </span><span class="pagenums">Chapters 6 Character Set Handling and 7 Locales and Internationalization. </span></p></div><div class="biblioentry"><a id="idp15797792"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="author"><span class="firstname">Roland</span> <span class="surname">McGrath</span>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2007 FSF. </span><span class="pagenums">Chapters 6 Character Set Handling and 7 Locales and Internationalization. </span></p></div><div class="biblioentry"><a id="idp15798144"></a><p><span class="citetitle"><em class="citetitle"> Correspondence - </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2002 . </span></p></div><div class="biblioentry"><a id="idp15800880"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2002 . </span></p></div><div class="biblioentry"><a id="idp15801232"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 14882:1998 Programming languages - C++ - </em>. </span><span class="copyright">Copyright © 1998 ISO. </span></p></div><div class="biblioentry"><a id="idp15803168"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="copyright">Copyright © 1998 ISO. </span></p></div><div class="biblioentry"><a id="idp15803520"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 9899:1999 Programming languages - C - </em>. </span><span class="copyright">Copyright © 1999 ISO. </span></p></div><div class="biblioentry"><a id="idp15805440"></a><p><span class="title"><em> + </em>. </span><span class="copyright">Copyright © 1999 ISO. </span></p></div><div class="biblioentry"><a id="idp15805792"></a><p><span class="title"><em> <a class="link" href="http://www.unix.org/version3/ieee_std.html" target="_top"> The Open Group Base Specifications, Issue 6 (IEEE Std. 1003.1-2004) </a> </em>. </span><span class="copyright">Copyright © 1999 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. </span></p></div><div class="biblioentry"><a id="idp15808688"></a><p><span class="citetitle"><em class="citetitle"> + The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. </span></p></div><div class="biblioentry"><a id="idp15809040"></a><p><span class="citetitle"><em class="citetitle"> The C++ Programming Language, Special Edition </em>. </span><span class="author"><span class="firstname">Bjarne</span> <span class="surname">Stroustrup</span>. </span><span class="copyright">Copyright © 2000 Addison Wesley, Inc.. </span><span class="pagenums">Appendix D. </span><span class="publisher"><span class="publishername"> Addison Wesley - . </span></span></p></div><div class="biblioentry"><a id="idp15813312"></a><p><span class="citetitle"><em class="citetitle"> + . </span></span></p></div><div class="biblioentry"><a id="idp15813664"></a><p><span class="citetitle"><em class="citetitle"> Standard C++ IOStreams and Locales </em>. </span><span class="subtitle"> Advanced Programmer's Guide and Reference @@ -409,42 +409,42 @@ codecvt usage. </p></li><li class="listitem"><p> wchar_t/char internal buffers and conversions between internal/external buffers? - </p></li></ul></div></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="facet.codecvt.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp15890848"></a><p><span class="citetitle"><em class="citetitle"> + </p></li></ul></div></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="facet.codecvt.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp15891136"></a><p><span class="citetitle"><em class="citetitle"> The GNU C Library </em>. </span><span class="author"><span class="firstname">Roland</span> <span class="surname">McGrath</span>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2007 FSF. </span><span class="pagenums"> Chapters 6 Character Set Handling and 7 Locales and Internationalization - . </span></p></div><div class="biblioentry"><a id="idp15895600"></a><p><span class="citetitle"><em class="citetitle"> + . </span></p></div><div class="biblioentry"><a id="idp15895888"></a><p><span class="citetitle"><em class="citetitle"> Correspondence - </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2002 . </span></p></div><div class="biblioentry"><a id="idp15898688"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2002 . </span></p></div><div class="biblioentry"><a id="idp15898976"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 14882:1998 Programming languages - C++ - </em>. </span><span class="copyright">Copyright © 1998 ISO. </span></p></div><div class="biblioentry"><a id="idp15900976"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="copyright">Copyright © 1998 ISO. </span></p></div><div class="biblioentry"><a id="idp15901264"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 9899:1999 Programming languages - C - </em>. </span><span class="copyright">Copyright © 1999 ISO. </span></p></div><div class="biblioentry"><a id="idp15903248"></a><p><span class="title"><em> + </em>. </span><span class="copyright">Copyright © 1999 ISO. </span></p></div><div class="biblioentry"><a id="idp15903536"></a><p><span class="title"><em> <a class="link" href="http://www.opengroup.org/austin/" target="_top"> System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) </a> </em>. </span><span class="copyright">Copyright © 2008 The Open Group/The Institute of Electrical and Electronics Engineers, Inc. - . </span></p></div><div class="biblioentry"><a id="idp15906480"></a><p><span class="citetitle"><em class="citetitle"> + . </span></p></div><div class="biblioentry"><a id="idp15906768"></a><p><span class="citetitle"><em class="citetitle"> The C++ Programming Language, Special Edition </em>. </span><span class="author"><span class="firstname">Bjarne</span> <span class="surname">Stroustrup</span>. </span><span class="copyright">Copyright © 2000 Addison Wesley, Inc.. </span><span class="pagenums">Appendix D. </span><span class="publisher"><span class="publishername"> Addison Wesley - . </span></span></p></div><div class="biblioentry"><a id="idp15911104"></a><p><span class="citetitle"><em class="citetitle"> + . </span></span></p></div><div class="biblioentry"><a id="idp15911392"></a><p><span class="citetitle"><em class="citetitle"> Standard C++ IOStreams and Locales </em>. </span><span class="subtitle"> Advanced Programmer's Guide and Reference . </span><span class="author"><span class="firstname">Angelika</span> <span class="surname">Langer</span>. </span><span class="author"><span class="firstname">Klaus</span> <span class="surname">Kreft</span>. </span><span class="copyright">Copyright © 2000 Addison Wesley Longman, Inc.. </span><span class="publisher"><span class="publishername"> Addison Wesley Longman - . </span></span></p></div><div class="biblioentry"><a id="idp15916768"></a><p><span class="title"><em> + . </span></span></p></div><div class="biblioentry"><a id="idp15917056"></a><p><span class="title"><em> <a class="link" href="http://www.lysator.liu.se/c/na1.html" target="_top"> A brief description of Normative Addendum 1 </a> - </em>. </span><span class="author"><span class="firstname">Clive</span> <span class="surname">Feather</span>. </span><span class="pagenums">Extended Character Sets. </span></p></div><div class="biblioentry"><a id="idp15920016"></a><p><span class="title"><em> + </em>. </span><span class="author"><span class="firstname">Clive</span> <span class="surname">Feather</span>. </span><span class="pagenums">Extended Character Sets. </span></p></div><div class="biblioentry"><a id="idp15920304"></a><p><span class="title"><em> <a class="link" href="http://tldp.org/HOWTO/Unicode-HOWTO.html" target="_top"> The Unicode HOWTO </a> - </em>. </span><span class="author"><span class="firstname">Bruno</span> <span class="surname">Haible</span>. </span></p></div><div class="biblioentry"><a id="idp15922800"></a><p><span class="title"><em> + </em>. </span><span class="author"><span class="firstname">Bruno</span> <span class="surname">Haible</span>. </span></p></div><div class="biblioentry"><a id="idp15923088"></a><p><span class="title"><em> <a class="link" href="http://www.cl.cam.ac.uk/~mgk25/unicode.html" target="_top"> UTF-8 and Unicode FAQ for Unix/Linux </a> @@ -690,39 +690,39 @@ void test01() model. As of this writing, it is unknown how to query to see if a specified message catalog exists using the gettext package. - </p></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="facet.messages.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp16003408"></a><p><span class="citetitle"><em class="citetitle"> + </p></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="facet.messages.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp16003632"></a><p><span class="citetitle"><em class="citetitle"> The GNU C Library </em>. </span><span class="author"><span class="firstname">Roland</span> <span class="surname">McGrath</span>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2007 FSF. </span><span class="pagenums">Chapters 6 Character Set Handling, and 7 Locales and Internationalization - . </span></p></div><div class="biblioentry"><a id="idp16008160"></a><p><span class="citetitle"><em class="citetitle"> + . </span></p></div><div class="biblioentry"><a id="idp16008384"></a><p><span class="citetitle"><em class="citetitle"> Correspondence - </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2002 . </span></p></div><div class="biblioentry"><a id="idp16011248"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2002 . </span></p></div><div class="biblioentry"><a id="idp16011472"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 14882:1998 Programming languages - C++ - </em>. </span><span class="copyright">Copyright © 1998 ISO. </span></p></div><div class="biblioentry"><a id="idp16013536"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="copyright">Copyright © 1998 ISO. </span></p></div><div class="biblioentry"><a id="idp16013760"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 9899:1999 Programming languages - C - </em>. </span><span class="copyright">Copyright © 1999 ISO. </span></p></div><div class="biblioentry"><a id="idp16015808"></a><p><span class="title"><em> + </em>. </span><span class="copyright">Copyright © 1999 ISO. </span></p></div><div class="biblioentry"><a id="idp16016032"></a><p><span class="title"><em> <a class="link" href="http://www.opengroup.org/austin/" target="_top"> System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) </a> </em>. </span><span class="copyright">Copyright © 2008 The Open Group/The Institute of Electrical and Electronics Engineers, Inc. - . </span></p></div><div class="biblioentry"><a id="idp16019040"></a><p><span class="citetitle"><em class="citetitle"> + . </span></p></div><div class="biblioentry"><a id="idp16019264"></a><p><span class="citetitle"><em class="citetitle"> The C++ Programming Language, Special Edition </em>. </span><span class="author"><span class="firstname">Bjarne</span> <span class="surname">Stroustrup</span>. </span><span class="copyright">Copyright © 2000 Addison Wesley, Inc.. </span><span class="pagenums">Appendix D. </span><span class="publisher"><span class="publishername"> Addison Wesley - . </span></span></p></div><div class="biblioentry"><a id="idp16023664"></a><p><span class="citetitle"><em class="citetitle"> + . </span></span></p></div><div class="biblioentry"><a id="idp16023888"></a><p><span class="citetitle"><em class="citetitle"> Standard C++ IOStreams and Locales </em>. </span><span class="subtitle"> Advanced Programmer's Guide and Reference . </span><span class="author"><span class="firstname">Angelika</span> <span class="surname">Langer</span>. </span><span class="author"><span class="firstname">Klaus</span> <span class="surname">Kreft</span>. </span><span class="copyright">Copyright © 2000 Addison Wesley Longman, Inc.. </span><span class="publisher"><span class="publishername"> Addison Wesley Longman - . </span></span></p></div><div class="biblioentry"><a id="idp16029328"></a><p><span class="title"><em> + . </span></span></p></div><div class="biblioentry"><a id="idp16029552"></a><p><span class="title"><em> <a class="link" href="http://java.sun.com/reference/api/index.html" target="_top"> API Specifications, Java Platform </a> </em>. </span><span class="pagenums">java.util.Properties, java.text.MessageFormat, java.util.Locale, java.util.ResourceBundle - . </span></p></div><div class="biblioentry"><a id="idp16031664"></a><p><span class="title"><em> + . </span></p></div><div class="biblioentry"><a id="idp16031888"></a><p><span class="title"><em> <a class="link" href="https://www.gnu.org/software/gettext/" target="_top"> GNU gettext tools, version 0.10.38, Native Language Support Library and Tools. diff --git a/libstdc++-v3/doc/html/manual/index.html b/libstdc++-v3/doc/html/manual/index.html index 82c86330dbe..4561b3aacc1 100644 --- a/libstdc++-v3/doc/html/manual/index.html +++ b/libstdc++-v3/doc/html/manual/index.html @@ -15,13 +15,13 @@ </a></span></dt><dd><dl><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions">Exceptions</a></span></dt><dd><dl><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions.api">API Reference</a></span></dt><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions.data">Adding Data to <code class="classname">exception</code></a></span></dt></dl></dd><dt><span class="section"><a href="concept_checking.html">Concept Checking</a></span></dt></dl></dd><dt><span class="chapter"><a href="utilities.html">6. Utilities -</a></span></dt><dd><dl><dt><span class="section"><a href="utilities.html#std.util.functors">Functors</a></span></dt><dt><span class="section"><a href="pairs.html">Pairs</a></span></dt><dt><span class="section"><a href="memory.html">Memory</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#std.util.memory.allocator">Allocators</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#allocator.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#allocator.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#allocator.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp13918736">Interface Design</a></span></dt><dt><span class="section"><a href="memory.html#idp13922288">Selecting Default Allocation Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp13935584">Disabling Memory Caching</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#allocator.using">Using a Specific Allocator</a></span></dt><dt><span class="section"><a href="memory.html#allocator.custom">Custom Allocators</a></span></dt><dt><span class="section"><a href="memory.html#allocator.ext">Extension Allocators</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.auto_ptr">auto_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#auto_ptr.limitations">Limitations</a></span></dt><dt><span class="section"><a href="memory.html#auto_ptr.using">Use in Containers</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.shared_ptr">shared_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#shared_ptr.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15511664">Class Hierarchy</a></span></dt><dt><span class="section"><a href="memory.html#idp15534176">Thread Safety</a></span></dt><dt><span class="section"><a href="memory.html#idp15541472">Selecting Lock Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp15556096">Related functions and classes</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.using">Use</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15572448">Examples</a></span></dt><dt><span class="section"><a href="memory.html#idp15576032">Unresolved Issues</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.ack">Acknowledgments</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="traits.html">Traits</a></span></dt></dl></dd><dt><span class="chapter"><a href="strings.html">7. +</a></span></dt><dd><dl><dt><span class="section"><a href="utilities.html#std.util.functors">Functors</a></span></dt><dt><span class="section"><a href="pairs.html">Pairs</a></span></dt><dt><span class="section"><a href="memory.html">Memory</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#std.util.memory.allocator">Allocators</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#allocator.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#allocator.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#allocator.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp13920976">Interface Design</a></span></dt><dt><span class="section"><a href="memory.html#idp13924528">Selecting Default Allocation Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp13937824">Disabling Memory Caching</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#allocator.using">Using a Specific Allocator</a></span></dt><dt><span class="section"><a href="memory.html#allocator.custom">Custom Allocators</a></span></dt><dt><span class="section"><a href="memory.html#allocator.ext">Extension Allocators</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.auto_ptr">auto_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#auto_ptr.limitations">Limitations</a></span></dt><dt><span class="section"><a href="memory.html#auto_ptr.using">Use in Containers</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.shared_ptr">shared_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#shared_ptr.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15512272">Class Hierarchy</a></span></dt><dt><span class="section"><a href="memory.html#idp15534784">Thread Safety</a></span></dt><dt><span class="section"><a href="memory.html#idp15542080">Selecting Lock Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp15556704">Related functions and classes</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.using">Use</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15573056">Examples</a></span></dt><dt><span class="section"><a href="memory.html#idp15576640">Unresolved Issues</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.ack">Acknowledgments</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="traits.html">Traits</a></span></dt></dl></dd><dt><span class="chapter"><a href="strings.html">7. Strings </a></span></dt><dd><dl><dt><span class="section"><a href="strings.html#std.strings.string">String Classes</a></span></dt><dd><dl><dt><span class="section"><a href="strings.html#strings.string.simple">Simple Transformations</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.case">Case Sensitivity</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.character_types">Arbitrary Character Types</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.token">Tokenizing</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.shrink">Shrink to Fit</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.Cstring">CString (MFC)</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="localization.html">8. Localization -</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales">Locales</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales.locale">locale</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locales.locale.req">Requirements</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.design">Design</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locale.impl.c">Interacting with "C" locales</a></span></dt></dl></dd><dt><span class="section"><a href="localization.html#locales.locale.future">Future</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="facets.html">Facets</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#std.localization.facet.ctype">ctype</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.ctype.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#idp15777920">Specializations</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.ctype.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#std.localization.facet.codecvt">codecvt</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.codecvt.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.design">Design</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#codecvt.design.wchar_t_size"><span class="type">wchar_t</span> Size</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.unicode">Support for Unicode</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.issues">Other Issues</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.codecvt.impl">Implementation</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#manual.localization.facet.messages">messages</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.messages.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.design">Design</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#messages.impl.models">Models</a></span></dt><dt><span class="section"><a href="facets.html#messages.impl.gnu">The GNU Model</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.messages.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.future">Future</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="chapter"><a href="containers.html">9. +</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales">Locales</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales.locale">locale</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locales.locale.req">Requirements</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.design">Design</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locale.impl.c">Interacting with "C" locales</a></span></dt></dl></dd><dt><span class="section"><a href="localization.html#locales.locale.future">Future</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="facets.html">Facets</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#std.localization.facet.ctype">ctype</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.ctype.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#idp15778336">Specializations</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.ctype.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#std.localization.facet.codecvt">codecvt</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.codecvt.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.design">Design</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#codecvt.design.wchar_t_size"><span class="type">wchar_t</span> Size</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.unicode">Support for Unicode</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.issues">Other Issues</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.codecvt.impl">Implementation</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#manual.localization.facet.messages">messages</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.messages.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.design">Design</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#messages.impl.models">Models</a></span></dt><dt><span class="section"><a href="facets.html#messages.impl.gnu">The GNU Model</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.messages.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.future">Future</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="chapter"><a href="containers.html">9. Containers </a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#std.containers.sequences">Sequences</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#containers.sequences.list">list</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#sequences.list.size">list::size() is O(n)</a></span></dt></dl></dd><dt><span class="section"><a href="containers.html#containers.sequences.vector">vector</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#sequences.vector.management">Space Overhead Management</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="associative.html">Associative</a></span></dt><dd><dl><dt><span class="section"><a href="associative.html#containers.associative.insert_hints">Insertion Hints</a></span></dt><dt><span class="section"><a href="associative.html#containers.associative.bitset">bitset</a></span></dt><dd><dl><dt><span class="section"><a href="associative.html#associative.bitset.size_variable">Size Variable</a></span></dt><dt><span class="section"><a href="associative.html#associative.bitset.type_string">Type String</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="unordered_associative.html">Unordered Associative</a></span></dt><dd><dl><dt><span class="section"><a href="unordered_associative.html#containers.unordered.hash">Hash Code</a></span></dt><dd><dl><dt><span class="section"><a href="unordered_associative.html#containers.unordered.cache">Hash Code Caching Policy</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="containers_and_c.html">Interacting with C</a></span></dt><dd><dl><dt><span class="section"><a href="containers_and_c.html#containers.c.vs_array">Containers vs. Arrays</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="iterators.html">10. @@ -143,19 +143,19 @@ Support for C++11 dialect. </a></span></dt><dt><span class="appendix"><a href="appendix_gpl.html">D. <acronym class="acronym">GNU</acronym> General Public License version 3 - </a></span></dt><dt><span class="appendix"><a href="appendix_gfdl.html">E. GNU Free Documentation License</a></span></dt></dl></dd></dl></div><div class="list-of-figures"><p><strong>List of Figures</strong></p><dl><dt>22.1. <a href="policy_data_structures.html#idp17613872">Node Invariants</a></dt><dt>22.2. <a href="policy_data_structures.html#idp17620592">Underlying Associative Data Structures</a></dt><dt>22.3. <a href="policy_data_structures.html#idp17652288">Range Iteration in Different Data Structures</a></dt><dt>22.4. <a href="policy_data_structures.html#idp17667200">Point Iteration in Hash Data Structures</a></dt><dt>22.5. <a href="policy_data_structures.html#idp17676464">Effect of erase in different underlying data structures</a></dt><dt>22.6. <a href="policy_data_structures.html#idp17743920">Underlying Priority Queue Data Structures</a></dt><dt>22.7. <a href="policy_data_structures_using.html#idp17806560">Exception Hierarchy</a></dt><dt>22.8. <a href="policy_data_structures_design.html#idp18000880">Non-unique Mapping Standard Containers</a></dt><dt>22.9. <a href="policy_data_structures_design.html#fig.pbds_embedded_lists_2"> + </a></span></dt><dt><span class="appendix"><a href="appendix_gfdl.html">E. GNU Free Documentation License</a></span></dt></dl></dd></dl></div><div class="list-of-figures"><p><strong>List of Figures</strong></p><dl><dt>22.1. <a href="policy_data_structures.html#idp17613296">Node Invariants</a></dt><dt>22.2. <a href="policy_data_structures.html#idp17619952">Underlying Associative Data Structures</a></dt><dt>22.3. <a href="policy_data_structures.html#idp17651648">Range Iteration in Different Data Structures</a></dt><dt>22.4. <a href="policy_data_structures.html#idp17666528">Point Iteration in Hash Data Structures</a></dt><dt>22.5. <a href="policy_data_structures.html#idp17675840">Effect of erase in different underlying data structures</a></dt><dt>22.6. <a href="policy_data_structures.html#idp17743424">Underlying Priority Queue Data Structures</a></dt><dt>22.7. <a href="policy_data_structures_using.html#idp17806128">Exception Hierarchy</a></dt><dt>22.8. <a href="policy_data_structures_design.html#idp18000448">Non-unique Mapping Standard Containers</a></dt><dt>22.9. <a href="policy_data_structures_design.html#fig.pbds_embedded_lists_2"> Effect of embedded lists in <code class="classname">std::multimap</code> - </a></dt><dt>22.10. <a href="policy_data_structures_design.html#idp18024384">Non-unique Mapping Containers</a></dt><dt>22.11. <a href="policy_data_structures_design.html#idp18044128">Point Iterator Hierarchy</a></dt><dt>22.12. <a href="policy_data_structures_design.html#idp18057472">Invalidation Guarantee Tags Hierarchy</a></dt><dt>22.13. <a href="policy_data_structures_design.html#idp18087696">Container Tag Hierarchy</a></dt><dt>22.14. <a href="policy_data_structures_design.html#idp18127776">Hash functions, ranged-hash functions, and - range-hashing functions</a></dt><dt>22.15. <a href="policy_data_structures_design.html#idp18192144">Insert hash sequence diagram</a></dt><dt>22.16. <a href="policy_data_structures_design.html#idp18199200">Insert hash sequence diagram with a null policy</a></dt><dt>22.17. <a href="policy_data_structures_design.html#idp18215888">Hash policy class diagram</a></dt><dt>22.18. <a href="policy_data_structures_design.html#idp18234992">Balls and bins</a></dt><dt>22.19. <a href="policy_data_structures_design.html#idp18265776">Insert resize sequence diagram</a></dt><dt>22.20. <a href="policy_data_structures_design.html#idp18273552">Standard resize policy trigger sequence - diagram</a></dt><dt>22.21. <a href="policy_data_structures_design.html#idp18277712">Standard resize policy size sequence - diagram</a></dt><dt>22.22. <a href="policy_data_structures_design.html#idp18355632">Tree node invariants</a></dt><dt>22.23. <a href="policy_data_structures_design.html#idp18365072">Tree node invalidation</a></dt><dt>22.24. <a href="policy_data_structures_design.html#idp18378176">A tree and its update policy</a></dt><dt>22.25. <a href="policy_data_structures_design.html#idp18389840">Restoring node invariants</a></dt><dt>22.26. <a href="policy_data_structures_design.html#idp18398016">Insert update sequence</a></dt><dt>22.27. <a href="policy_data_structures_design.html#idp18420272">Useless update path</a></dt><dt>22.28. <a href="policy_data_structures_design.html#idp18465024">A PATRICIA trie</a></dt><dt>22.29. <a href="policy_data_structures_design.html#idp18475456">A trie and its update policy</a></dt><dt>22.30. <a href="policy_data_structures_design.html#idp18505968">A simple list</a></dt><dt>22.31. <a href="policy_data_structures_design.html#idp18511552">The counter algorithm</a></dt><dt>22.32. <a href="policy_data_structures_design.html#idp18575312">Underlying Priority-Queue Data-Structures.</a></dt><dt>22.33. <a href="policy_data_structures_design.html#idp18610288">Priority-Queue Data-Structure Tags.</a></dt><dt>B.1. <a href="appendix_porting.html#idp22035008">Configure and Build File Dependencies</a></dt></dl></div><div class="list-of-tables"><p><strong>List of Tables</strong></p><dl><dt>1.1. <a href="status.html#idp1142240">C++ 1998/2003 Implementation Status</a></dt><dt>1.2. <a href="status.html#idp9027792">C++ 2011 Implementation Status</a></dt><dt>1.3. <a href="status.html#idp8179360">C++ TR1 Implementation Status</a></dt><dt>1.4. <a href="status.html#idp12556688">C++ TR 24733 Implementation Status</a></dt><dt>3.1. <a href="using.html#idp13049824">C++ Command Options</a></dt><dt>3.2. <a href="using_headers.html#idp13077248">C++ 1998 Library Headers</a></dt><dt>3.3. <a href="using_headers.html#idp13113728">C++ 1998 Library Headers for C Library Facilities</a></dt><dt>3.4. <a href="using_headers.html#idp13138464">C++ 2011 Library Headers</a></dt><dt>3.5. <a href="using_headers.html#idp13189904">C++ 2011 Library Headers for C Library Facilities</a></dt><dt>3.6. <a href="using_headers.html#idp13219792">C++ TR 1 Library Headers</a></dt><dt>3.7. <a href="using_headers.html#idp13236720">C++ TR 1 Library Headers for C Library Facilities</a></dt><dt>3.8. <a href="using_headers.html#idp13257792">C++ TR 24733 Decimal Floating-Point Header</a></dt><dt>3.9. <a href="using_headers.html#idp13263312">C++ ABI Headers</a></dt><dt>3.10. <a href="using_headers.html#idp13269712">Extension Headers</a></dt><dt>3.11. <a href="using_headers.html#idp13305440">Extension Debug Headers</a></dt><dt>3.12. <a href="using_headers.html#idp13320208">Extension Profile Headers</a></dt><dt>3.13. <a href="using_headers.html#idp13333584">Extension Parallel Headers</a></dt><dt>17.1. <a href="debug_mode_using.html#idp16490080">Debugging Containers</a></dt><dt>17.2. <a href="debug_mode_using.html#idp16534976">Debugging Containers C++11</a></dt><dt>18.1. <a href="parallel_mode_using.html#idp16726048">Parallel Algorithms</a></dt><dt>19.1. <a href="profile_mode_design.html#idp16981328">Profile Code Location</a></dt><dt>19.2. <a href="profile_mode_diagnostics.html#idp17088784">Profile Diagnostics</a></dt><dt>21.1. <a href="bitmap_allocator_impl.html#idp17501232">Bitmap Allocator Memory Map</a></dt><dt>B.1. <a href="documentation_hacking.html#idp22161856">Doxygen Prerequisites</a></dt><dt>B.2. <a href="documentation_hacking.html#idp22237520">HTML to Doxygen Markup Comparison</a></dt><dt>B.3. <a href="documentation_hacking.html#idp22256960">Docbook Prerequisites</a></dt><dt>B.4. <a href="documentation_hacking.html#idp22334528">HTML to Docbook XML Markup Comparison</a></dt><dt>B.5. <a href="documentation_hacking.html#idp22358672">Docbook XML Element Use</a></dt><dt>B.6. <a href="api.html#idp23029888">Extension Allocators</a></dt><dt>B.7. <a href="api.html#idp23057520">Extension Allocators Continued</a></dt></dl></div><div class="list-of-equations"><p><strong>List of Equations</strong></p><dl><dt>22.1. <a href="policy_data_structures_design.html#idp18141584">Ranged Hash Function</a></dt><dt>22.2. <a href="policy_data_structures_design.html#idp18147472">Range-Hashing, Division Method</a></dt><dt>22.3. <a href="policy_data_structures_design.html#idp18151984">Division via Prime Modulo</a></dt><dt>22.4. <a href="policy_data_structures_design.html#idp18153808">Division via Bit Mask</a></dt><dt>22.5. <a href="policy_data_structures_design.html#idp18163440"> + </a></dt><dt>22.10. <a href="policy_data_structures_design.html#idp18023952">Non-unique Mapping Containers</a></dt><dt>22.11. <a href="policy_data_structures_design.html#idp18043824">Point Iterator Hierarchy</a></dt><dt>22.12. <a href="policy_data_structures_design.html#idp18057168">Invalidation Guarantee Tags Hierarchy</a></dt><dt>22.13. <a href="policy_data_structures_design.html#idp18087392">Container Tag Hierarchy</a></dt><dt>22.14. <a href="policy_data_structures_design.html#idp18127536">Hash functions, ranged-hash functions, and + range-hashing functions</a></dt><dt>22.15. <a href="policy_data_structures_design.html#idp18191968">Insert hash sequence diagram</a></dt><dt>22.16. <a href="policy_data_structures_design.html#idp18199024">Insert hash sequence diagram with a null policy</a></dt><dt>22.17. <a href="policy_data_structures_design.html#idp18215840">Hash policy class diagram</a></dt><dt>22.18. <a href="policy_data_structures_design.html#idp18234944">Balls and bins</a></dt><dt>22.19. <a href="policy_data_structures_design.html#idp18265728">Insert resize sequence diagram</a></dt><dt>22.20. <a href="policy_data_structures_design.html#idp18273504">Standard resize policy trigger sequence + diagram</a></dt><dt>22.21. <a href="policy_data_structures_design.html#idp18277664">Standard resize policy size sequence + diagram</a></dt><dt>22.22. <a href="policy_data_structures_design.html#idp18355696">Tree node invariants</a></dt><dt>22.23. <a href="policy_data_structures_design.html#idp18365136">Tree node invalidation</a></dt><dt>22.24. <a href="policy_data_structures_design.html#idp18378304">A tree and its update policy</a></dt><dt>22.25. <a href="policy_data_structures_design.html#idp18389968">Restoring node invariants</a></dt><dt>22.26. <a href="policy_data_structures_design.html#idp18398144">Insert update sequence</a></dt><dt>22.27. <a href="policy_data_structures_design.html#idp18420400">Useless update path</a></dt><dt>22.28. <a href="policy_data_structures_design.html#idp18465088">A PATRICIA trie</a></dt><dt>22.29. <a href="policy_data_structures_design.html#idp18475584">A trie and its update policy</a></dt><dt>22.30. <a href="policy_data_structures_design.html#idp18506160">A simple list</a></dt><dt>22.31. <a href="policy_data_structures_design.html#idp18511744">The counter algorithm</a></dt><dt>22.32. <a href="policy_data_structures_design.html#idp18575568">Underlying Priority-Queue Data-Structures.</a></dt><dt>22.33. <a href="policy_data_structures_design.html#idp18610544">Priority-Queue Data-Structure Tags.</a></dt><dt>B.1. <a href="appendix_porting.html#idp22035648">Configure and Build File Dependencies</a></dt></dl></div><div class="list-of-tables"><p><strong>List of Tables</strong></p><dl><dt>1.1. <a href="status.html#idp452240">C++ 1998/2003 Implementation Status</a></dt><dt>1.2. <a href="status.html#idp8670848">C++ 2011 Implementation Status</a></dt><dt>1.3. <a href="status.html#idp7483200">C++ TR1 Implementation Status</a></dt><dt>1.4. <a href="status.html#idp12559072">C++ TR 24733 Implementation Status</a></dt><dt>3.1. <a href="using.html#idp13051936">C++ Command Options</a></dt><dt>3.2. <a href="using_headers.html#idp13079360">C++ 1998 Library Headers</a></dt><dt>3.3. <a href="using_headers.html#idp13115840">C++ 1998 Library Headers for C Library Facilities</a></dt><dt>3.4. <a href="using_headers.html#idp13140576">C++ 2011 Library Headers</a></dt><dt>3.5. <a href="using_headers.html#idp13192016">C++ 2011 Library Headers for C Library Facilities</a></dt><dt>3.6. <a href="using_headers.html#idp13221904">C++ TR 1 Library Headers</a></dt><dt>3.7. <a href="using_headers.html#idp13238832">C++ TR 1 Library Headers for C Library Facilities</a></dt><dt>3.8. <a href="using_headers.html#idp13259904">C++ TR 24733 Decimal Floating-Point Header</a></dt><dt>3.9. <a href="using_headers.html#idp13265424">C++ ABI Headers</a></dt><dt>3.10. <a href="using_headers.html#idp13271824">Extension Headers</a></dt><dt>3.11. <a href="using_headers.html#idp13307552">Extension Debug Headers</a></dt><dt>3.12. <a href="using_headers.html#idp13322320">Extension Profile Headers</a></dt><dt>3.13. <a href="using_headers.html#idp13335696">Extension Parallel Headers</a></dt><dt>17.1. <a href="debug_mode_using.html#idp16490400">Debugging Containers</a></dt><dt>17.2. <a href="debug_mode_using.html#idp16535296">Debugging Containers C++11</a></dt><dt>18.1. <a href="parallel_mode_using.html#idp16725920">Parallel Algorithms</a></dt><dt>19.1. <a href="profile_mode_design.html#idp16981200">Profile Code Location</a></dt><dt>19.2. <a href="profile_mode_diagnostics.html#idp17088912">Profile Diagnostics</a></dt><dt>21.1. <a href="bitmap_allocator_impl.html#idp17500848">Bitmap Allocator Memory Map</a></dt><dt>B.1. <a href="documentation_hacking.html#idp22162432">Doxygen Prerequisites</a></dt><dt>B.2. <a href="documentation_hacking.html#idp22238096">HTML to Doxygen Markup Comparison</a></dt><dt>B.3. <a href="documentation_hacking.html#idp22257536">Docbook Prerequisites</a></dt><dt>B.4. <a href="documentation_hacking.html#idp22335040">HTML to Docbook XML Markup Comparison</a></dt><dt>B.5. <a href="documentation_hacking.html#idp22359184">Docbook XML Element Use</a></dt><dt>B.6. <a href="api.html#idp23030528">Extension Allocators</a></dt><dt>B.7. <a href="api.html#idp23058160">Extension Allocators Continued</a></dt></dl></div><div class="list-of-equations"><p><strong>List of Equations</strong></p><dl><dt>22.1. <a href="policy_data_structures_design.html#idp18141344">Ranged Hash Function</a></dt><dt>22.2. <a href="policy_data_structures_design.html#idp18147232">Range-Hashing, Division Method</a></dt><dt>22.3. <a href="policy_data_structures_design.html#idp18151744">Division via Prime Modulo</a></dt><dt>22.4. <a href="policy_data_structures_design.html#idp18153568">Division via Bit Mask</a></dt><dt>22.5. <a href="policy_data_structures_design.html#idp18163200"> A Standard String Hash Function - </a></dt><dt>22.6. <a href="policy_data_structures_design.html#idp18169584"> + </a></dt><dt>22.6. <a href="policy_data_structures_design.html#idp18169344"> Only k String DNA Hash - </a></dt><dt>22.7. <a href="policy_data_structures_design.html#idp18240496"> + </a></dt><dt>22.7. <a href="policy_data_structures_design.html#idp18240448"> Probability of Probe Sequence of Length k - </a></dt><dt>22.8. <a href="policy_data_structures_design.html#idp18247264"> + </a></dt><dt>22.8. <a href="policy_data_structures_design.html#idp18247216"> Probability Probe Sequence in Some Bin </a></dt></dl></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="../index.html">Prev</a> </td><td width="20%" align="center"> </td><td width="40%" align="right"> <a accesskey="n" href="intro.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">The GNU C++ Library </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Part I. Introduction diff --git a/libstdc++-v3/doc/html/manual/intro.html b/libstdc++-v3/doc/html/manual/intro.html index b6da970265f..b7eaed9fba5 100644 --- a/libstdc++-v3/doc/html/manual/intro.html +++ b/libstdc++-v3/doc/html/manual/intro.html @@ -4,5 +4,5 @@ </th></tr><tr><td width="20%" align="left"><a accesskey="p" href="index.html">Prev</a> </td><th width="60%" align="center">The GNU C++ Library Manual</th><td width="20%" align="right"> <a accesskey="n" href="status.html">Next</a></td></tr></table><hr /></div><div class="part"><div class="titlepage"><div><div><h1 class="title"><a id="manual.intro"></a>Part I. Introduction - <a id="idp1287872" class="indexterm"></a> + <a id="idp9040416" class="indexterm"></a> </h1></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="chapter"><a href="status.html">1. Status</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#manual.intro.status.iso">Implementation Status</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#status.iso.1998">C++ 1998/2003</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.1998.status">Implementation Status</a></span></dt><dt><span class="section"><a href="status.html#iso.1998.specific">Implementation Specific Behavior</a></span></dt></dl></dd><dt><span class="section"><a href="status.html#status.iso.2011">C++ 2011</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.2011.specific">Implementation Specific Behavior</a></span></dt></dl></dd><dt><span class="section"><a href="status.html#status.iso.tr1">C++ TR1</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.tr1.specific">Implementation Specific Behavior</a></span></dt></dl></dd><dt><span class="section"><a href="status.html#status.iso.tr24733">C++ TR 24733</a></span></dt></dl></dd><dt><span class="section"><a href="license.html">License</a></span></dt><dd><dl><dt><span class="section"><a href="license.html#manual.intro.status.license.gpl">The Code: GPL</a></span></dt><dt><span class="section"><a href="license.html#manual.intro.status.license.fdl">The Documentation: GPL, FDL</a></span></dt></dl></dd><dt><span class="section"><a href="bugs.html">Bugs</a></span></dt><dd><dl><dt><span class="section"><a href="bugs.html#manual.intro.status.bugs.impl">Implementation Bugs</a></span></dt><dt><span class="section"><a href="bugs.html#manual.intro.status.bugs.iso">Standard Bugs</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="setup.html">2. Setup</a></span></dt><dd><dl><dt><span class="section"><a href="setup.html#manual.intro.setup.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="configure.html">Configure</a></span></dt><dt><span class="section"><a href="make.html">Make</a></span></dt></dl></dd><dt><span class="chapter"><a href="using.html">3. Using</a></span></dt><dd><dl><dt><span class="section"><a href="using.html#manual.intro.using.flags">Command Options</a></span></dt><dt><span class="section"><a href="using_headers.html">Headers</a></span></dt><dd><dl><dt><span class="section"><a href="using_headers.html#manual.intro.using.headers.all">Header Files</a></span></dt><dt><span class="section"><a href="using_headers.html#manual.intro.using.headers.mixing">Mixing Headers</a></span></dt><dt><span class="section"><a href="using_headers.html#manual.intro.using.headers.cheaders">The C Headers and <code class="code">namespace std</code></a></span></dt><dt><span class="section"><a href="using_headers.html#manual.intro.using.headers.pre">Precompiled Headers</a></span></dt></dl></dd><dt><span class="section"><a href="using_macros.html">Macros</a></span></dt><dt><span class="section"><a href="using_namespaces.html">Namespaces</a></span></dt><dd><dl><dt><span class="section"><a href="using_namespaces.html#manual.intro.using.namespaces.all">Available Namespaces</a></span></dt><dt><span class="section"><a href="using_namespaces.html#manual.intro.using.namespaces.std">namespace std</a></span></dt><dt><span class="section"><a href="using_namespaces.html#manual.intro.using.namespaces.comp">Using Namespace Composition</a></span></dt></dl></dd><dt><span class="section"><a href="using_dynamic_or_shared.html">Linking</a></span></dt><dd><dl><dt><span class="section"><a href="using_dynamic_or_shared.html#manual.intro.using.linkage.freestanding">Almost Nothing</a></span></dt><dt><span class="section"><a href="using_dynamic_or_shared.html#manual.intro.using.linkage.dynamic">Finding Dynamic or Shared Libraries</a></span></dt></dl></dd><dt><span class="section"><a href="using_concurrency.html">Concurrency</a></span></dt><dd><dl><dt><span class="section"><a href="using_concurrency.html#manual.intro.using.concurrency.prereq">Prerequisites</a></span></dt><dt><span class="section"><a href="using_concurrency.html#manual.intro.using.concurrency.thread_safety">Thread Safety</a></span></dt><dt><span class="section"><a href="using_concurrency.html#manual.intro.using.concurrency.atomics">Atomics</a></span></dt><dt><span class="section"><a href="using_concurrency.html#manual.intro.using.concurrency.io">IO</a></span></dt><dd><dl><dt><span class="section"><a href="using_concurrency.html#concurrency.io.structure">Structure</a></span></dt><dt><span class="section"><a href="using_concurrency.html#concurrency.io.defaults">Defaults</a></span></dt><dt><span class="section"><a href="using_concurrency.html#concurrency.io.future">Future</a></span></dt><dt><span class="section"><a href="using_concurrency.html#concurrency.io.alt">Alternatives</a></span></dt></dl></dd><dt><span class="section"><a href="using_concurrency.html#manual.intro.using.concurrency.containers">Containers</a></span></dt></dl></dd><dt><span class="section"><a href="using_exceptions.html">Exceptions</a></span></dt><dd><dl><dt><span class="section"><a href="using_exceptions.html#intro.using.exception.safety">Exception Safety</a></span></dt><dt><span class="section"><a href="using_exceptions.html#intro.using.exception.propagating">Exception Neutrality</a></span></dt><dt><span class="section"><a href="using_exceptions.html#intro.using.exception.no">Doing without</a></span></dt><dt><span class="section"><a href="using_exceptions.html#intro.using.exception.compat">Compatibility</a></span></dt><dd><dl><dt><span class="section"><a href="using_exceptions.html#using.exception.compat.c">With <code class="literal">C</code></a></span></dt><dt><span class="section"><a href="using_exceptions.html#using.exception.compat.posix">With <code class="literal">POSIX</code> thread cancellation</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="debug.html">Debugging Support</a></span></dt><dd><dl><dt><span class="section"><a href="debug.html#debug.compiler">Using <span class="command"><strong>g++</strong></span></a></span></dt><dt><span class="section"><a href="debug.html#debug.req">Debug Versions of Library Binary Files</a></span></dt><dt><span class="section"><a href="debug.html#debug.memory">Memory Leak Hunting</a></span></dt><dt><span class="section"><a href="debug.html#debug.races">Data Race Hunting</a></span></dt><dt><span class="section"><a href="debug.html#debug.gdb">Using <span class="command"><strong>gdb</strong></span></a></span></dt><dt><span class="section"><a href="debug.html#debug.exceptions">Tracking uncaught exceptions</a></span></dt><dt><span class="section"><a href="debug.html#debug.debug_mode">Debug Mode</a></span></dt><dt><span class="section"><a href="debug.html#debug.compile_time_checks">Compile Time Checking</a></span></dt><dt><span class="section"><a href="debug.html#debug.profile_mode">Profile-based Performance Analysis</a></span></dt></dl></dd></dl></dd></dl></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="index.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="index.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="status.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">The GNU C++ Library Manual </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Chapter 1. Status</td></tr></table></div></body></html>
\ No newline at end of file diff --git a/libstdc++-v3/doc/html/manual/io.html b/libstdc++-v3/doc/html/manual/io.html index 54319852762..c7c972c7238 100644 --- a/libstdc++-v3/doc/html/manual/io.html +++ b/libstdc++-v3/doc/html/manual/io.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="streambufs.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.io"></a>Chapter 13. Input and Output - <a id="idp16257360" class="indexterm"></a> + <a id="idp16257600" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="io.html#std.io.objects">Iostream Objects</a></span></dt><dt><span class="section"><a href="streambufs.html">Stream Buffers</a></span></dt><dd><dl><dt><span class="section"><a href="streambufs.html#io.streambuf.derived">Derived streambuf Classes</a></span></dt><dt><span class="section"><a href="streambufs.html#io.streambuf.buffering">Buffering</a></span></dt></dl></dd><dt><span class="section"><a href="stringstreams.html">Memory Based Streams</a></span></dt><dd><dl><dt><span class="section"><a href="stringstreams.html#std.io.memstreams.compat">Compatibility With strstream</a></span></dt></dl></dd><dt><span class="section"><a href="fstreams.html">File Based Streams</a></span></dt><dd><dl><dt><span class="section"><a href="fstreams.html#std.io.filestreams.copying_a_file">Copying a File</a></span></dt><dt><span class="section"><a href="fstreams.html#std.io.filestreams.binary">Binary Input and Output</a></span></dt></dl></dd><dt><span class="section"><a href="io_and_c.html">Interacting with C</a></span></dt><dd><dl><dt><span class="section"><a href="io_and_c.html#std.io.c.FILE">Using FILE* and file descriptors</a></span></dt><dt><span class="section"><a href="io_and_c.html#std.io.c.sync">Performance</a></span></dt></dl></dd></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.io.objects"></a>Iostream Objects</h2></div></div></div><p>To minimize the time you have to wait on the compiler, it's good to only include the headers you really need. Many people simply include <iostream> when they don't need to -- and that can <span class="emphasis"><em>penalize diff --git a/libstdc++-v3/doc/html/manual/iterators.html b/libstdc++-v3/doc/html/manual/iterators.html index cbc02247622..58518572576 100644 --- a/libstdc++-v3/doc/html/manual/iterators.html +++ b/libstdc++-v3/doc/html/manual/iterators.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="algorithms.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.iterators"></a>Chapter 10. Iterators - <a id="idp16156816" class="indexterm"></a> + <a id="idp16156992" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="iterators.html#std.iterators.predefined">Predefined</a></span></dt><dd><dl><dt><span class="section"><a href="iterators.html#iterators.predefined.vs_pointers">Iterators vs. Pointers</a></span></dt><dt><span class="section"><a href="iterators.html#iterators.predefined.end">One Past the End</a></span></dt></dl></dd></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.iterators.predefined"></a>Predefined</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="iterators.predefined.vs_pointers"></a>Iterators vs. Pointers</h3></div></div></div><p> The following FAQ <a class="link" href="../faq.html#faq.iterator_as_pod" title="7.1.">entry</a> points out that diff --git a/libstdc++-v3/doc/html/manual/localization.html b/libstdc++-v3/doc/html/manual/localization.html index 873c1813279..a595f22eb15 100644 --- a/libstdc++-v3/doc/html/manual/localization.html +++ b/libstdc++-v3/doc/html/manual/localization.html @@ -6,8 +6,8 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="facets.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.localization"></a>Chapter 8. Localization - <a id="idp15700736" class="indexterm"></a> -</h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="localization.html#std.localization.locales">Locales</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales.locale">locale</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locales.locale.req">Requirements</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.design">Design</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locale.impl.c">Interacting with "C" locales</a></span></dt></dl></dd><dt><span class="section"><a href="localization.html#locales.locale.future">Future</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="facets.html">Facets</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#std.localization.facet.ctype">ctype</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.ctype.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#idp15777920">Specializations</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.ctype.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#std.localization.facet.codecvt">codecvt</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.codecvt.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.design">Design</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#codecvt.design.wchar_t_size"><span class="type">wchar_t</span> Size</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.unicode">Support for Unicode</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.issues">Other Issues</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.codecvt.impl">Implementation</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#manual.localization.facet.messages">messages</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.messages.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.design">Design</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#messages.impl.models">Models</a></span></dt><dt><span class="section"><a href="facets.html#messages.impl.gnu">The GNU Model</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.messages.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.future">Future</a></span></dt></dl></dd></dl></dd></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.localization.locales"></a>Locales</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="std.localization.locales.locale"></a>locale</h3></div></div></div><p> + <a id="idp15701088" class="indexterm"></a> +</h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="localization.html#std.localization.locales">Locales</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales.locale">locale</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locales.locale.req">Requirements</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.design">Design</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locale.impl.c">Interacting with "C" locales</a></span></dt></dl></dd><dt><span class="section"><a href="localization.html#locales.locale.future">Future</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="facets.html">Facets</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#std.localization.facet.ctype">ctype</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.ctype.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#idp15778336">Specializations</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.ctype.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#std.localization.facet.codecvt">codecvt</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.codecvt.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.design">Design</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#codecvt.design.wchar_t_size"><span class="type">wchar_t</span> Size</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.unicode">Support for Unicode</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.issues">Other Issues</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.codecvt.impl">Implementation</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#manual.localization.facet.messages">messages</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.messages.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.design">Design</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#messages.impl.models">Models</a></span></dt><dt><span class="section"><a href="facets.html#messages.impl.gnu">The GNU Model</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.messages.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.future">Future</a></span></dt></dl></dd></dl></dd></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.localization.locales"></a>Locales</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="std.localization.locales.locale"></a>locale</h3></div></div></div><p> Describes the basic locale object, including nested classes id, facet, and the reference-counted implementation object, class _Impl. @@ -402,29 +402,29 @@ global locale" (emphasis Paolo), that is: What should non-required facet instantiations do? If the generic implementation is provided, then how to end-users provide specializations? - </p></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="locales.locale.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp15743648"></a><p><span class="citetitle"><em class="citetitle"> + </p></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="locales.locale.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp15744064"></a><p><span class="citetitle"><em class="citetitle"> The GNU C Library </em>. </span><span class="author"><span class="firstname">Roland</span> <span class="surname">McGrath</span>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2007 FSF. </span><span class="pagenums"> Chapters 6 Character Set Handling and 7 Locales and Internationalization - . </span></p></div><div class="biblioentry"><a id="idp15748416"></a><p><span class="citetitle"><em class="citetitle"> + . </span></p></div><div class="biblioentry"><a id="idp15748832"></a><p><span class="citetitle"><em class="citetitle"> Correspondence - </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2002 . </span></p></div><div class="biblioentry"><a id="idp15751504"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="author"><span class="firstname">Ulrich</span> <span class="surname">Drepper</span>. </span><span class="copyright">Copyright © 2002 . </span></p></div><div class="biblioentry"><a id="idp15751920"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 14882:1998 Programming languages - C++ - </em>. </span><span class="copyright">Copyright © 1998 ISO. </span></p></div><div class="biblioentry"><a id="idp15753792"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="copyright">Copyright © 1998 ISO. </span></p></div><div class="biblioentry"><a id="idp15754208"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 9899:1999 Programming languages - C - </em>. </span><span class="copyright">Copyright © 1999 ISO. </span></p></div><div class="biblioentry"><a id="idp15756064"></a><p><span class="title"><em> + </em>. </span><span class="copyright">Copyright © 1999 ISO. </span></p></div><div class="biblioentry"><a id="idp15756480"></a><p><span class="title"><em> <a class="link" href="http://www.opengroup.org/austin/" target="_top"> System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) </a> </em>. </span><span class="copyright">Copyright © 2008 The Open Group/The Institute of Electrical and Electronics Engineers, Inc. - . </span></p></div><div class="biblioentry"><a id="idp15759296"></a><p><span class="citetitle"><em class="citetitle"> + . </span></p></div><div class="biblioentry"><a id="idp15759712"></a><p><span class="citetitle"><em class="citetitle"> The C++ Programming Language, Special Edition </em>. </span><span class="author"><span class="firstname">Bjarne</span> <span class="surname">Stroustrup</span>. </span><span class="copyright">Copyright © 2000 Addison Wesley, Inc.. </span><span class="pagenums">Appendix D. </span><span class="publisher"><span class="publishername"> Addison Wesley - . </span></span></p></div><div class="biblioentry"><a id="idp15763920"></a><p><span class="citetitle"><em class="citetitle"> + . </span></span></p></div><div class="biblioentry"><a id="idp15764336"></a><p><span class="citetitle"><em class="citetitle"> Standard C++ IOStreams and Locales </em>. </span><span class="subtitle"> Advanced Programmer's Guide and Reference diff --git a/libstdc++-v3/doc/html/manual/memory.html b/libstdc++-v3/doc/html/manual/memory.html index 934cb0043ef..b31c49da96f 100644 --- a/libstdc++-v3/doc/html/manual/memory.html +++ b/libstdc++-v3/doc/html/manual/memory.html @@ -92,7 +92,7 @@ or loading and unloading shared objects in memory. As such, using caching allocators on systems that do not support <code class="function">abi::__cxa_atexit</code> is not recommended. - </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="allocator.impl"></a>Implementation</h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp13918736"></a>Interface Design</h5></div></div></div><p> + </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="allocator.impl"></a>Implementation</h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp13920976"></a>Interface Design</h5></div></div></div><p> The only allocator interface that is supported is the standard C++ interface. As such, all STL containers have been adjusted, and all external allocators have @@ -105,7 +105,7 @@ </p><p> The base class that <code class="classname">allocator</code> is derived from may not be user-configurable. -</p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp13922288"></a>Selecting Default Allocation Policy</h5></div></div></div><p> +</p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp13924528"></a>Selecting Default Allocation Policy</h5></div></div></div><p> It's difficult to pick an allocation strategy that will provide maximum utility, without excessively penalizing some behavior. In fact, it's difficult just deciding which typical actions to measure @@ -142,7 +142,7 @@ The current default choice for <code class="classname">allocator</code> is <code class="classname">__gnu_cxx::new_allocator</code>. - </p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp13935584"></a>Disabling Memory Caching</h5></div></div></div><p> + </p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp13937824"></a>Disabling Memory Caching</h5></div></div></div><p> In use, <code class="classname">allocator</code> may allocate and deallocate using implementation-specific strategies and heuristics. Because of this, a given call to an allocator object's @@ -309,33 +309,33 @@ of the used and unused memory locations. It has its own <a class="link" href="bitmap_allocator.html" title="Chapter 21. The bitmap_allocator">chapter</a> in the documentation. - </p></li></ol></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="allocator.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp13990544"></a><p><span class="citetitle"><em class="citetitle"> + </p></li></ol></div></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="allocator.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp13992848"></a><p><span class="citetitle"><em class="citetitle"> ISO/IEC 14882:1998 Programming languages - C++ </em>. </span> isoc++_1998 - <span class="pagenums">20.4 Memory. </span></p></div><div class="biblioentry"><a id="idp13992384"></a><p><span class="title"><em> + <span class="pagenums">20.4 Memory. </span></p></div><div class="biblioentry"><a id="idp13994688"></a><p><span class="title"><em> <a class="link" href="http://www.drdobbs.com/cpp/184403759" target="_top"> The Standard Librarian: What Are Allocators Good For? </a> </em>. </span><span class="author"><span class="firstname">Matt</span> <span class="surname">Austern</span>. </span><span class="publisher"><span class="publishername"> C/C++ Users Journal - . </span></span></p></div><div class="biblioentry"><a id="idp13996112"></a><p><span class="title"><em> + . </span></span></p></div><div class="biblioentry"><a id="idp13998416"></a><p><span class="title"><em> <a class="link" href="http://www.hoard.org/" target="_top"> The Hoard Memory Allocator </a> - </em>. </span><span class="author"><span class="firstname">Emery</span> <span class="surname">Berger</span>. </span></p></div><div class="biblioentry"><a id="idp13998880"></a><p><span class="title"><em> + </em>. </span><span class="author"><span class="firstname">Emery</span> <span class="surname">Berger</span>. </span></p></div><div class="biblioentry"><a id="idp14001184"></a><p><span class="title"><em> <a class="link" href="http://people.cs.umass.edu/~emery/pubs/berger-oopsla2002.pdf" target="_top"> Reconsidering Custom Memory Allocation </a> - </em>. </span><span class="author"><span class="firstname">Emery</span> <span class="surname">Berger</span>. </span><span class="author"><span class="firstname">Ben</span> <span class="surname">Zorn</span>. </span><span class="author"><span class="firstname">Kathryn</span> <span class="surname">McKinley</span>. </span><span class="copyright">Copyright © 2002 OOPSLA. </span></p></div><div class="biblioentry"><a id="idp14005040"></a><p><span class="title"><em> + </em>. </span><span class="author"><span class="firstname">Emery</span> <span class="surname">Berger</span>. </span><span class="author"><span class="firstname">Ben</span> <span class="surname">Zorn</span>. </span><span class="author"><span class="firstname">Kathryn</span> <span class="surname">McKinley</span>. </span><span class="copyright">Copyright © 2002 OOPSLA. </span></p></div><div class="biblioentry"><a id="idp14007344"></a><p><span class="title"><em> <a class="link" href="http://www.angelikalanger.com/Articles/C++Report/Allocators/Allocators.html" target="_top"> Allocator Types </a> </em>. </span><span class="author"><span class="firstname">Klaus</span> <span class="surname">Kreft</span>. </span><span class="author"><span class="firstname">Angelika</span> <span class="surname">Langer</span>. </span><span class="publisher"><span class="publishername"> C/C++ Users Journal - . </span></span></p></div><div class="biblioentry"><a id="idp14009776"></a><p><span class="citetitle"><em class="citetitle">The C++ Programming Language</em>. </span><span class="author"><span class="firstname">Bjarne</span> <span class="surname">Stroustrup</span>. </span><span class="copyright">Copyright © 2000 . </span><span class="pagenums">19.4 Allocators. </span><span class="publisher"><span class="publishername"> + . </span></span></p></div><div class="biblioentry"><a id="idp14012080"></a><p><span class="citetitle"><em class="citetitle">The C++ Programming Language</em>. </span><span class="author"><span class="firstname">Bjarne</span> <span class="surname">Stroustrup</span>. </span><span class="copyright">Copyright © 2000 . </span><span class="pagenums">19.4 Allocators. </span><span class="publisher"><span class="publishername"> Addison Wesley - . </span></span></p></div><div class="biblioentry"><a id="idp14014208"></a><p><span class="citetitle"><em class="citetitle">Yalloc: A Recycling C++ Allocator</em>. </span><span class="author"><span class="firstname">Felix</span> <span class="surname">Yen</span>. </span></p></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="std.util.memory.auto_ptr"></a>auto_ptr</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="auto_ptr.limitations"></a>Limitations</h4></div></div></div><p>Explaining all of the fun and delicious things that can + . </span></span></p></div><div class="biblioentry"><a id="idp14016512"></a><p><span class="citetitle"><em class="citetitle">Yalloc: A Recycling C++ Allocator</em>. </span><span class="author"><span class="firstname">Felix</span> <span class="surname">Yen</span>. </span></p></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="std.util.memory.auto_ptr"></a>auto_ptr</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="auto_ptr.limitations"></a>Limitations</h4></div></div></div><p>Explaining all of the fun and delicious things that can happen with misuse of the <code class="classname">auto_ptr</code> class template (called <acronym class="acronym">AP</acronym> here) would take some time. Suffice it to say that the use of <acronym class="acronym">AP</acronym> @@ -445,7 +445,7 @@ drops to zero. Derived classes override those functions to destroy resources in a context where the correct dynamic type is known. This is an application of the technique known as type erasure. - </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="shared_ptr.impl"></a>Implementation</h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15511664"></a>Class Hierarchy</h5></div></div></div><p> + </p></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="shared_ptr.impl"></a>Implementation</h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15512272"></a>Class Hierarchy</h5></div></div></div><p> A <code class="classname">shared_ptr<T></code> contains a pointer of type <span class="type">T*</span> and an object of type <code class="classname">__shared_count</code>. The shared_count contains a @@ -492,7 +492,7 @@ C++11-only features are: rvalue-ref/move support, allocator support, aliasing constructor, make_shared & allocate_shared. Additionally, the constructors taking <code class="classname">auto_ptr</code> parameters are deprecated in C++11 mode. - </p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15534176"></a>Thread Safety</h5></div></div></div><p> + </p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15534784"></a>Thread Safety</h5></div></div></div><p> The <a class="link" href="http://boost.org/libs/smart_ptr/shared_ptr.htm#ThreadSafety" target="_top">Thread Safety</a> section of the Boost shared_ptr documentation says "shared_ptr @@ -537,7 +537,7 @@ compiler, standard library, platform etc. For the version of shared_ptr in libstdc++ the compiler and library are fixed, which makes things much simpler: we have an atomic CAS or we don't, see Lock Policy below for details. -</p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15541472"></a>Selecting Lock Policy</h5></div></div></div><p> +</p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15542080"></a>Selecting Lock Policy</h5></div></div></div><p> </p><p> There is a single <code class="classname">_Sp_counted_base</code> class, which is a template parameterized on the enum @@ -578,7 +578,7 @@ used when libstdc++ is built without <code class="literal">--enable-threads</cod <code class="filename">ext/atomicity.h</code>, which detect if the program is multi-threaded. If only one thread of execution exists in the program then less expensive non-atomic operations are used. - </p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15556096"></a>Related functions and classes</h5></div></div></div><div class="variablelist"><dl class="variablelist"><dt><span class="term"><code class="code">dynamic_pointer_cast</code>, <code class="code">static_pointer_cast</code>, + </p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15556704"></a>Related functions and classes</h5></div></div></div><div class="variablelist"><dl class="variablelist"><dt><span class="term"><code class="code">dynamic_pointer_cast</code>, <code class="code">static_pointer_cast</code>, <code class="code">const_pointer_cast</code></span></dt><dd><p> As noted in N2351, these functions can be implemented non-intrusively using the alias constructor. However the aliasing constructor is only available @@ -611,13 +611,13 @@ is called. Users should not try to use this. As well as the extra constructors, this implementation also needs some members of _Sp_counted_deleter to be protected where they could otherwise be private. - </p></dd></dl></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="shared_ptr.using"></a>Use</h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15572448"></a>Examples</h5></div></div></div><p> + </p></dd></dl></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="shared_ptr.using"></a>Use</h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15573056"></a>Examples</h5></div></div></div><p> Examples of use can be found in the testsuite, under <code class="filename">testsuite/tr1/2_general_utilities/shared_ptr</code>, <code class="filename">testsuite/20_util/shared_ptr</code> and <code class="filename">testsuite/20_util/weak_ptr</code>. - </p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15576032"></a>Unresolved Issues</h5></div></div></div><p> + </p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="idp15576640"></a>Unresolved Issues</h5></div></div></div><p> The <span class="emphasis"><em><code class="classname">shared_ptr</code> atomic access</em></span> clause in the C++11 standard is not implemented in GCC. </p><p> @@ -658,25 +658,25 @@ be private. code to work with, Peter Dimov in particular for his help and invaluable advice on thread safety. Phillip Jordan and Paolo Carlini for the lock policy implementation. - </p></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="shared_ptr.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp15587392"></a><p><span class="title"><em> + </p></div><div class="bibliography"><div class="titlepage"><div><div><h4 class="title"><a id="shared_ptr.biblio"></a>Bibliography</h4></div></div></div><div class="biblioentry"><a id="idp15587936"></a><p><span class="title"><em> <a class="link" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2351.htm" target="_top"> Improving shared_ptr for C++0x, Revision 2 </a> </em>. </span><span class="subtitle"> N2351 - . </span></p></div><div class="biblioentry"><a id="idp15589680"></a><p><span class="title"><em> + . </span></p></div><div class="biblioentry"><a id="idp15590224"></a><p><span class="title"><em> <a class="link" href="http://open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2456.html" target="_top"> C++ Standard Library Active Issues List </a> </em>. </span><span class="subtitle"> N2456 - . </span></p></div><div class="biblioentry"><a id="idp15591968"></a><p><span class="title"><em> + . </span></p></div><div class="biblioentry"><a id="idp15592512"></a><p><span class="title"><em> <a class="link" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf" target="_top"> Working Draft, Standard for Programming Language C++ </a> </em>. </span><span class="subtitle"> N2461 - . </span></p></div><div class="biblioentry"><a id="idp15594272"></a><p><span class="title"><em> + . </span></p></div><div class="biblioentry"><a id="idp15594816"></a><p><span class="title"><em> <a class="link" href="http://boost.org/libs/smart_ptr/shared_ptr.htm" target="_top"> Boost C++ Libraries documentation, shared_ptr </a> diff --git a/libstdc++-v3/doc/html/manual/numerics.html b/libstdc++-v3/doc/html/manual/numerics.html index 26e5afb3add..2d85c4be258 100644 --- a/libstdc++-v3/doc/html/manual/numerics.html +++ b/libstdc++-v3/doc/html/manual/numerics.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="generalized_numeric_operations.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.numerics"></a>Chapter 12. Numerics - <a id="idp16214400" class="indexterm"></a> + <a id="idp16214640" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="numerics.html#std.numerics.complex">Complex</a></span></dt><dd><dl><dt><span class="section"><a href="numerics.html#numerics.complex.processing">complex Processing</a></span></dt></dl></dd><dt><span class="section"><a href="generalized_numeric_operations.html">Generalized Operations</a></span></dt><dt><span class="section"><a href="numerics_and_c.html">Interacting with C</a></span></dt><dd><dl><dt><span class="section"><a href="numerics_and_c.html#numerics.c.array">Numerics vs. Arrays</a></span></dt><dt><span class="section"><a href="numerics_and_c.html#numerics.c.c99">C99</a></span></dt></dl></dd></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.numerics.complex"></a>Complex</h2></div></div></div><p> </p><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="numerics.complex.processing"></a>complex Processing</h3></div></div></div><p> </p><p>Using <code class="code">complex<></code> becomes even more comple- er, sorry, diff --git a/libstdc++-v3/doc/html/manual/parallel_mode.html b/libstdc++-v3/doc/html/manual/parallel_mode.html index 55b53fa9f62..5aee5f91d1a 100644 --- a/libstdc++-v3/doc/html/manual/parallel_mode.html +++ b/libstdc++-v3/doc/html/manual/parallel_mode.html @@ -12,11 +12,11 @@ explicit source declaration or by compiling existing sources with a specific compiler flag. </p><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="manual.ext.parallel_mode.intro"></a>Intro</h2></div></div></div><p>The following library components in the include <code class="filename">numeric</code> are included in the parallel mode:</p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p><code class="function">std::accumulate</code></p></li><li class="listitem"><p><code class="function">std::adjacent_difference</code></p></li><li class="listitem"><p><code class="function">std::inner_product</code></p></li><li class="listitem"><p><code class="function">std::partial_sum</code></p></li></ul></div><p>The following library components in the include -<code class="filename">algorithm</code> are included in the parallel mode:</p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p><code class="function">std::adjacent_find</code></p></li><li class="listitem"><p><code class="function">std::count</code></p></li><li class="listitem"><p><code class="function">std::count_if</code></p></li><li class="listitem"><p><code class="function">std::equal</code></p></li><li class="listitem"><p><code class="function">std::find</code></p></li><li class="listitem"><p><code class="function">std::find_if</code></p></li><li class="listitem"><p><code class="function">std::find_first_of</code></p></li><li class="listitem"><p><code class="function">std::for_each</code></p></li><li class="listitem"><p><code class="function">std::generate</code></p></li><li class="listitem"><p><code class="function">std::generate_n</code></p></li><li class="listitem"><p><code class="function">std::lexicographical_compare</code></p></li><li class="listitem"><p><code class="function">std::mismatch</code></p></li><li class="listitem"><p><code class="function">std::search</code></p></li><li class="listitem"><p><code class="function">std::search_n</code></p></li><li class="listitem"><p><code class="function">std::transform</code></p></li><li class="listitem"><p><code class="function">std::replace</code></p></li><li class="listitem"><p><code class="function">std::replace_if</code></p></li><li class="listitem"><p><code class="function">std::max_element</code></p></li><li class="listitem"><p><code class="function">std::merge</code></p></li><li class="listitem"><p><code class="function">std::min_element</code></p></li><li class="listitem"><p><code class="function">std::nth_element</code></p></li><li class="listitem"><p><code class="function">std::partial_sort</code></p></li><li class="listitem"><p><code class="function">std::partition</code></p></li><li class="listitem"><p><code class="function">std::random_shuffle</code></p></li><li class="listitem"><p><code class="function">std::set_union</code></p></li><li class="listitem"><p><code class="function">std::set_intersection</code></p></li><li class="listitem"><p><code class="function">std::set_symmetric_difference</code></p></li><li class="listitem"><p><code class="function">std::set_difference</code></p></li><li class="listitem"><p><code class="function">std::sort</code></p></li><li class="listitem"><p><code class="function">std::stable_sort</code></p></li><li class="listitem"><p><code class="function">std::unique_copy</code></p></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h2 class="title"><a id="parallel_mode.biblio"></a>Bibliography</h2></div></div></div><div class="biblioentry"><a id="idp16926928"></a><p><span class="citetitle"><em class="citetitle"> +<code class="filename">algorithm</code> are included in the parallel mode:</p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p><code class="function">std::adjacent_find</code></p></li><li class="listitem"><p><code class="function">std::count</code></p></li><li class="listitem"><p><code class="function">std::count_if</code></p></li><li class="listitem"><p><code class="function">std::equal</code></p></li><li class="listitem"><p><code class="function">std::find</code></p></li><li class="listitem"><p><code class="function">std::find_if</code></p></li><li class="listitem"><p><code class="function">std::find_first_of</code></p></li><li class="listitem"><p><code class="function">std::for_each</code></p></li><li class="listitem"><p><code class="function">std::generate</code></p></li><li class="listitem"><p><code class="function">std::generate_n</code></p></li><li class="listitem"><p><code class="function">std::lexicographical_compare</code></p></li><li class="listitem"><p><code class="function">std::mismatch</code></p></li><li class="listitem"><p><code class="function">std::search</code></p></li><li class="listitem"><p><code class="function">std::search_n</code></p></li><li class="listitem"><p><code class="function">std::transform</code></p></li><li class="listitem"><p><code class="function">std::replace</code></p></li><li class="listitem"><p><code class="function">std::replace_if</code></p></li><li class="listitem"><p><code class="function">std::max_element</code></p></li><li class="listitem"><p><code class="function">std::merge</code></p></li><li class="listitem"><p><code class="function">std::min_element</code></p></li><li class="listitem"><p><code class="function">std::nth_element</code></p></li><li class="listitem"><p><code class="function">std::partial_sort</code></p></li><li class="listitem"><p><code class="function">std::partition</code></p></li><li class="listitem"><p><code class="function">std::random_shuffle</code></p></li><li class="listitem"><p><code class="function">std::set_union</code></p></li><li class="listitem"><p><code class="function">std::set_intersection</code></p></li><li class="listitem"><p><code class="function">std::set_symmetric_difference</code></p></li><li class="listitem"><p><code class="function">std::set_difference</code></p></li><li class="listitem"><p><code class="function">std::sort</code></p></li><li class="listitem"><p><code class="function">std::stable_sort</code></p></li><li class="listitem"><p><code class="function">std::unique_copy</code></p></li></ul></div></div><div class="bibliography"><div class="titlepage"><div><div><h2 class="title"><a id="parallel_mode.biblio"></a>Bibliography</h2></div></div></div><div class="biblioentry"><a id="idp16926864"></a><p><span class="citetitle"><em class="citetitle"> Parallelization of Bulk Operations for STL Dictionaries </em>. </span><span class="author"><span class="firstname">Johannes</span> <span class="surname">Singler</span>. </span><span class="author"><span class="firstname">Leonor</span> <span class="surname">Frias</span>. </span><span class="copyright">Copyright © 2007 . </span><span class="publisher"><span class="publishername"> Workshop on Highly Parallel Processing on a Chip (HPPC) 2007. (LNCS) - . </span></span></p></div><div class="biblioentry"><a id="idp16932000"></a><p><span class="citetitle"><em class="citetitle"> + . </span></span></p></div><div class="biblioentry"><a id="idp16931936"></a><p><span class="citetitle"><em class="citetitle"> The Multi-Core Standard Template Library </em>. </span><span class="author"><span class="firstname">Johannes</span> <span class="surname">Singler</span>. </span><span class="author"><span class="firstname">Peter</span> <span class="surname">Sanders</span>. </span><span class="author"><span class="firstname">Felix</span> <span class="surname">Putze</span>. </span><span class="copyright">Copyright © 2007 . </span><span class="publisher"><span class="publishername"> Euro-Par 2007: Parallel Processing. (LNCS 4641) diff --git a/libstdc++-v3/doc/html/manual/parallel_mode_using.html b/libstdc++-v3/doc/html/manual/parallel_mode_using.html index 68a0c1f6770..98bdb17beeb 100644 --- a/libstdc++-v3/doc/html/manual/parallel_mode_using.html +++ b/libstdc++-v3/doc/html/manual/parallel_mode_using.html @@ -62,4 +62,4 @@ Then compile this code with the prerequisite compiler flags flags for atomic operations.) </p><p> The following table provides the names and headers of all the parallel algorithms that can be used in a similar manner: -</p><div class="table"><a id="idp16726048"></a><p class="title"><strong>Table 18.1. Parallel Algorithms</strong></p><div class="table-contents"><table summary="Parallel Algorithms" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Algorithm</th><th align="left">Header</th><th align="left">Parallel algorithm</th><th align="left">Parallel header</th></tr></thead><tbody><tr><td align="left"><code class="function">std::accumulate</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="function">__gnu_parallel::accumulate</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr><tr><td align="left"><code class="function">std::adjacent_difference</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="function">__gnu_parallel::adjacent_difference</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr><tr><td align="left"><code class="function">std::inner_product</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="function">__gnu_parallel::inner_product</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr><tr><td align="left"><code class="function">std::partial_sum</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="function">__gnu_parallel::partial_sum</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr><tr><td align="left"><code class="function">std::adjacent_find</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::adjacent_find</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::count</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::count</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::count_if</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::count_if</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::equal</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::equal</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::find</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::find</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::find_if</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::find_if</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::find_first_of</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::find_first_of</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::for_each</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::for_each</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::generate</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::generate</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::generate_n</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::generate_n</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::lexicographical_compare</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::lexicographical_compare</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::mismatch</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::mismatch</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::search</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::search</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::search_n</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::search_n</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::transform</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::transform</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::replace</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::replace</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::replace_if</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::replace_if</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::max_element</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::max_element</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::merge</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::merge</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::min_element</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::min_element</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::nth_element</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::nth_element</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::partial_sort</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::partial_sort</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::partition</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::partition</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::random_shuffle</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::random_shuffle</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::set_union</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::set_union</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::set_intersection</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::set_intersection</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::set_symmetric_difference</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::set_symmetric_difference</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::set_difference</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::set_difference</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::sort</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::sort</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::stable_sort</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::stable_sort</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::unique_copy</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::unique_copy</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="parallel_mode_semantics.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="parallel_mode.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="parallel_mode_design.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Semantics </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Design</td></tr></table></div></body></html>
\ No newline at end of file +</p><div class="table"><a id="idp16725920"></a><p class="title"><strong>Table 18.1. Parallel Algorithms</strong></p><div class="table-contents"><table summary="Parallel Algorithms" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Algorithm</th><th align="left">Header</th><th align="left">Parallel algorithm</th><th align="left">Parallel header</th></tr></thead><tbody><tr><td align="left"><code class="function">std::accumulate</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="function">__gnu_parallel::accumulate</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr><tr><td align="left"><code class="function">std::adjacent_difference</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="function">__gnu_parallel::adjacent_difference</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr><tr><td align="left"><code class="function">std::inner_product</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="function">__gnu_parallel::inner_product</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr><tr><td align="left"><code class="function">std::partial_sum</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="function">__gnu_parallel::partial_sum</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr><tr><td align="left"><code class="function">std::adjacent_find</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::adjacent_find</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::count</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::count</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::count_if</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::count_if</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::equal</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::equal</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::find</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::find</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::find_if</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::find_if</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::find_first_of</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::find_first_of</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::for_each</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::for_each</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::generate</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::generate</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::generate_n</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::generate_n</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::lexicographical_compare</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::lexicographical_compare</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::mismatch</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::mismatch</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::search</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::search</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::search_n</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::search_n</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::transform</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::transform</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::replace</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::replace</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::replace_if</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::replace_if</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::max_element</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::max_element</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::merge</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::merge</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::min_element</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::min_element</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::nth_element</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::nth_element</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::partial_sort</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::partial_sort</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::partition</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::partition</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::random_shuffle</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::random_shuffle</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::set_union</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::set_union</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::set_intersection</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::set_intersection</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::set_symmetric_difference</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::set_symmetric_difference</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::set_difference</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::set_difference</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::sort</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::sort</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::stable_sort</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::stable_sort</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr><tr><td align="left"><code class="function">std::unique_copy</code></td><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="function">__gnu_parallel::unique_copy</code></td><td align="left"><code class="filename">parallel/algorithm</code></td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="parallel_mode_semantics.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="parallel_mode.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="parallel_mode_design.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Semantics </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Design</td></tr></table></div></body></html>
\ No newline at end of file diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures.html b/libstdc++-v3/doc/html/manual/policy_data_structures.html index f98fd4d6b26..6a5fa65527a 100644 --- a/libstdc++-v3/doc/html/manual/policy_data_structures.html +++ b/libstdc++-v3/doc/html/manual/policy_data_structures.html @@ -248,7 +248,7 @@ these invariants, one must supply some policy that is aware of these changes. Without this, it would be better to use a linked list (in itself very efficient for these purposes). - </p></li></ol></div><div class="figure"><a id="idp17613872"></a><p class="title"><strong>Figure 22.1. Node Invariants</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_node_invariants.png" align="middle" alt="Node Invariants" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="motivation.associative.underlying"></a>Underlying Data Structures</h5></div></div></div><p> + </p></li></ol></div><div class="figure"><a id="idp17613296"></a><p class="title"><strong>Figure 22.1. Node Invariants</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_node_invariants.png" align="middle" alt="Node Invariants" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="motivation.associative.underlying"></a>Underlying Data Structures</h5></div></div></div><p> The standard C++ library contains associative containers based on red-black trees and collision-chaining hash tables. These are very useful, but they are not ideal for all types of @@ -256,7 +256,7 @@ </p><p> The figure below shows the different underlying data structures currently supported in this library. - </p><div class="figure"><a id="idp17620592"></a><p class="title"><strong>Figure 22.2. Underlying Associative Data Structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_different_underlying_dss_1.png" align="middle" alt="Underlying Associative Data Structures" /></div></div></div><br class="figure-break" /><p> + </p><div class="figure"><a id="idp17619952"></a><p class="title"><strong>Figure 22.2. Underlying Associative Data Structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_different_underlying_dss_1.png" align="middle" alt="Underlying Associative Data Structures" /></div></div></div><br class="figure-break" /><p> A shows a collision-chaining hash-table, B shows a probing hash-table, C shows a red-black tree, D shows a splay tree, E shows a tree based on an ordered vector(implicit in the order of the @@ -375,7 +375,7 @@ no guarantee that the elements traversed will coincide with the <span class="emphasis"><em>logical</em></span> elements between 1 and 5, as in label B. - </p><div class="figure"><a id="idp17652288"></a><p class="title"><strong>Figure 22.3. Range Iteration in Different Data Structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_point_iterators_range_ops_1.png" align="middle" alt="Node Invariants" /></div></div></div><br class="figure-break" /><p> + </p><div class="figure"><a id="idp17651648"></a><p class="title"><strong>Figure 22.3. Range Iteration in Different Data Structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_point_iterators_range_ops_1.png" align="middle" alt="Node Invariants" /></div></div></div><br class="figure-break" /><p> In our opinion, this problem is not caused just because red-black trees are order preserving while collision-chaining hash tables are (generally) not - it @@ -426,7 +426,7 @@ list, as in the graphic below, label B. Here the iterators are as light as can be, but the hash-table's operations are more complicated. - </p><div class="figure"><a id="idp17667200"></a><p class="title"><strong>Figure 22.4. Point Iteration in Hash Data Structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_point_iterators_range_ops_2.png" align="middle" alt="Point Iteration in Hash Data Structures" /></div></div></div><br class="figure-break" /><p> + </p><div class="figure"><a id="idp17666528"></a><p class="title"><strong>Figure 22.4. Point Iteration in Hash Data Structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_point_iterators_range_ops_2.png" align="middle" alt="Point Iteration in Hash Data Structures" /></div></div></div><br class="figure-break" /><p> It should be noted that containers based on collision-chaining hash-tables are not the only ones with this type of behavior; many other self-organizing data structures display it as well. @@ -442,7 +442,7 @@ container. The graphic below shows three cases: A1 and A2 show a red-black tree; B1 and B2 show a probing hash-table; C1 and C2 show a collision-chaining hash table. - </p><div class="figure"><a id="idp17676464"></a><p class="title"><strong>Figure 22.5. Effect of erase in different underlying data structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_invalidation_guarantee_erase.png" align="middle" alt="Effect of erase in different underlying data structures" /></div></div></div><br class="figure-break" /><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p> + </p><div class="figure"><a id="idp17675840"></a><p class="title"><strong>Figure 22.5. Effect of erase in different underlying data structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_invalidation_guarantee_erase.png" align="middle" alt="Effect of erase in different underlying data structures" /></div></div></div><br class="figure-break" /><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p> Erasing 5 from A1 yields A2. Clearly, an iterator to 3 can be de-referenced and incremented. The sequence of iterators changed, but in a way that is well-defined by the interface. @@ -678,7 +678,7 @@ typically less structured than an associative container's tree; the third simply uses an associative container. These are shown in the figure below with labels A1 and A2, B, and C. - </p><div class="figure"><a id="idp17743920"></a><p class="title"><strong>Figure 22.6. Underlying Priority Queue Data Structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_different_underlying_dss_2.png" align="middle" alt="Underlying Priority Queue Data Structures" /></div></div></div><br class="figure-break" /><p> + </p><div class="figure"><a id="idp17743424"></a><p class="title"><strong>Figure 22.6. Underlying Priority Queue Data Structures</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_different_underlying_dss_2.png" align="middle" alt="Underlying Priority Queue Data Structures" /></div></div></div><br class="figure-break" /><p> No single implementation can completely replace any of the others. Some have better <code class="function">push</code> and <code class="function">pop</code> amortized performance, some have diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures_design.html b/libstdc++-v3/doc/html/manual/policy_data_structures_design.html index 1aa97fa611b..03a7daa5b6d 100644 --- a/libstdc++-v3/doc/html/manual/policy_data_structures_design.html +++ b/libstdc++-v3/doc/html/manual/policy_data_structures_design.html @@ -170,7 +170,7 @@ naturally; collision-chaining hash tables (label B) store equivalent-key values in the same bucket, the bucket can be arranged so that equivalent-key values are consecutive. - </p><div class="figure"><a id="idp18000880"></a><p class="title"><strong>Figure 22.8. Non-unique Mapping Standard Containers</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_embedded_lists_1.png" align="middle" alt="Non-unique Mapping Standard Containers" /></div></div></div><br class="figure-break" /><p> + </p><div class="figure"><a id="idp18000448"></a><p class="title"><strong>Figure 22.8. Non-unique Mapping Standard Containers</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_embedded_lists_1.png" align="middle" alt="Non-unique Mapping Standard Containers" /></div></div></div><br class="figure-break" /><p> Put differently, the standards' non-unique mapping associative-containers are associative containers that map primary keys to linked lists that are embedded into the @@ -252,7 +252,7 @@ first graphic above. Labels A and B, respectively. Each shaded box represents some size-type or secondary associative-container. - </p><div class="figure"><a id="idp18024384"></a><p class="title"><strong>Figure 22.10. Non-unique Mapping Containers</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_embedded_lists_3.png" align="middle" alt="Non-unique Mapping Containers" /></div></div></div><br class="figure-break" /><p> + </p><div class="figure"><a id="idp18023952"></a><p class="title"><strong>Figure 22.10. Non-unique Mapping Containers</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_embedded_lists_3.png" align="middle" alt="Non-unique Mapping Containers" /></div></div></div><br class="figure-break" /><p> In the first example above, then, one would use an associative container mapping each user to an associative container which maps each application id to a start time (see @@ -305,7 +305,7 @@ shows invariants for order-preserving containers: point-type iterators are synonymous with range-type iterators. Orthogonally, <span class="emphasis"><em>C</em></span>shows invariants for "set" - containers: iterators are synonymous with const iterators.</p><div class="figure"><a id="idp18044128"></a><p class="title"><strong>Figure 22.11. Point Iterator Hierarchy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_point_iterator_hierarchy.png" align="middle" alt="Point Iterator Hierarchy" /></div></div></div><br class="figure-break" /><p>Note that point-type iterators in self-organizing containers + containers: iterators are synonymous with const iterators.</p><div class="figure"><a id="idp18043824"></a><p class="title"><strong>Figure 22.11. Point Iterator Hierarchy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_point_iterator_hierarchy.png" align="middle" alt="Point Iterator Hierarchy" /></div></div></div><br class="figure-break" /><p>Note that point-type iterators in self-organizing containers (hash-based associative containers) lack movement operators, such as <code class="literal">operator++</code> - in fact, this is the reason why this library differentiates from the standard C++ librarys @@ -344,7 +344,7 @@ to the question of whether point-type iterators and range-type iterators are valid. The graphic below shows tags corresponding to different types of invalidation guarantees. - </p><div class="figure"><a id="idp18057472"></a><p class="title"><strong>Figure 22.12. Invalidation Guarantee Tags Hierarchy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_invalidation_tag_hierarchy.png" align="middle" alt="Invalidation Guarantee Tags Hierarchy" /></div></div></div><br class="figure-break" /><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p> + </p><div class="figure"><a id="idp18057168"></a><p class="title"><strong>Figure 22.12. Invalidation Guarantee Tags Hierarchy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_invalidation_tag_hierarchy.png" align="middle" alt="Invalidation Guarantee Tags Hierarchy" /></div></div></div><br class="figure-break" /><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p> <code class="classname">basic_invalidation_guarantee</code> corresponds to a basic guarantee that a point-type iterator, a found pointer, or a found reference, remains valid as long @@ -428,7 +428,7 @@ </p><p> This library contains a container tag hierarchy corresponding to the diagram below. - </p><div class="figure"><a id="idp18087696"></a><p class="title"><strong>Figure 22.13. Container Tag Hierarchy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_container_tag_hierarchy.png" align="middle" alt="Container Tag Hierarchy" /></div></div></div><br class="figure-break" /><p> + </p><div class="figure"><a id="idp18087392"></a><p class="title"><strong>Figure 22.13. Container Tag Hierarchy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_container_tag_hierarchy.png" align="middle" alt="Container Tag Hierarchy" /></div></div></div><br class="figure-break" /><p> Given any container <span class="type">Cntnr</span>, the tag of the underlying data structure can be found via <code class="literal">typename Cntnr::container_category</code>. @@ -487,7 +487,7 @@ collision-chaining container, except for the following.</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p><code class="classname">Comb_Probe_Fn</code> describes how to transform a probe sequence into a sequence of positions within the table.</p></li><li class="listitem"><p><code class="classname">Probe_Fn</code> describes a probe sequence policy.</p></li></ol></div><p>Some of the default template values depend on the values of other parameters, and are explained below.</p></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="container.hash.details"></a>Details</h5></div></div></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.hash.details.hash_policies"></a>Hash Policies</h6></div></div></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="details.hash_policies.general"></a>General</h6></div></div></div><p>Following is an explanation of some functions which hashing - involves. The graphic below illustrates the discussion.</p><div class="figure"><a id="idp18127776"></a><p class="title"><strong>Figure 22.14. Hash functions, ranged-hash functions, and + involves. The graphic below illustrates the discussion.</p><div class="figure"><a id="idp18127536"></a><p class="title"><strong>Figure 22.14. Hash functions, ranged-hash functions, and range-hashing functions</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_hash_ranged_hash_range_hashing_fns.png" align="middle" alt="Hash functions, ranged-hash functions, and range-hashing functions" /></div></div></div><br class="figure-break" /><p>Let U be a domain (e.g., the integers, or the strings of 3 characters). A hash-table algorithm needs to map elements of U "uniformly" into the range [0,..., m - @@ -504,7 +504,7 @@ Z<sub>+</sub>,</p><p>which maps a non-negative hash value, and a non-negative range upper-bound into a non-negative integral in the range between 0 (inclusive) and the range upper bound (exclusive), - i.e., for any r in Z<sub>+</sub>,</p><p>0 ≤ g(r, m) ≤ m - 1</p><p>The resulting ranged-hash function, is</p><div class="equation"><a id="idp18141584"></a><p class="title"><strong>Equation 22.1. Ranged Hash Function</strong></p><div class="equation-contents"><span class="mathphrase"> + i.e., for any r in Z<sub>+</sub>,</p><p>0 ≤ g(r, m) ≤ m - 1</p><p>The resulting ranged-hash function, is</p><div class="equation"><a id="idp18141344"></a><p class="title"><strong>Equation 22.1. Ranged Hash Function</strong></p><div class="equation-contents"><span class="mathphrase"> f(u , m) = g(h(u), m) </span></div></div><br class="equation-break" /><p>From the above, it is obvious that given g and h, f can always be composed (however the converse @@ -524,7 +524,7 @@ transforming the sequence of hash values into a sequence of positions.</p></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="details.hash_policies.range"></a>Range Hashing</h6></div></div></div><p>Some common choices for range-hashing functions are the division, multiplication, and middle-square methods (<a class="xref" href="policy_data_structures.html#biblio.knuth98sorting" title="The Art of Computer Programming - Sorting and Searching">[biblio.knuth98sorting]</a>), defined - as</p><div class="equation"><a id="idp18147472"></a><p class="title"><strong>Equation 22.2. Range-Hashing, Division Method</strong></p><div class="equation-contents"><span class="mathphrase"> + as</p><div class="equation"><a id="idp18147232"></a><p class="title"><strong>Equation 22.2. Range-Hashing, Division Method</strong></p><div class="equation-contents"><span class="mathphrase"> g(r, m) = r mod m </span></div></div><br class="equation-break" /><p>g(r, m) = ⌈ u/v ( a r mod v ) ⌉</p><p>and</p><p>g(r, m) = ⌈ u/v ( r<sup>2</sup> mod v ) ⌉</p><p>respectively, for some positive integrals u and v (typically powers of 2), and some a. Each of @@ -535,9 +535,9 @@ implement using the low level % (modulo) operation (for any m), or the low level & (bit-mask) operation (for the case where - m is a power of 2), i.e.,</p><div class="equation"><a id="idp18151984"></a><p class="title"><strong>Equation 22.3. Division via Prime Modulo</strong></p><div class="equation-contents"><span class="mathphrase"> + m is a power of 2), i.e.,</p><div class="equation"><a id="idp18151744"></a><p class="title"><strong>Equation 22.3. Division via Prime Modulo</strong></p><div class="equation-contents"><span class="mathphrase"> g(r, m) = r % m - </span></div></div><br class="equation-break" /><p>and</p><div class="equation"><a id="idp18153808"></a><p class="title"><strong>Equation 22.4. Division via Bit Mask</strong></p><div class="equation-contents"><span class="mathphrase"> + </span></div></div><br class="equation-break" /><p>and</p><div class="equation"><a id="idp18153568"></a><p class="title"><strong>Equation 22.4. Division via Bit Mask</strong></p><div class="equation-contents"><span class="mathphrase"> g(r, m) = r & m - 1, (with m = 2<sup>k</sup> for some k) </span></div></div><br class="equation-break" /><p>respectively.</p><p>The % (modulo) implementation has the advantage that for @@ -563,7 +563,7 @@ s = [ s<sub>0</sub>,..., s<sub>t - 1</sub>] </p><p>be a string of t characters, each of which is from domain S. Consider the following ranged-hash - function:</p><div class="equation"><a id="idp18163440"></a><p class="title"><strong>Equation 22.5. + function:</p><div class="equation"><a id="idp18163200"></a><p class="title"><strong>Equation 22.5. A Standard String Hash Function </strong></p><div class="equation-contents"><span class="mathphrase"> f<sub>1</sub>(s, m) = ∑ <sub>i = @@ -575,7 +575,7 @@ of a long DNA sequence (and so S = {'A', 'C', 'G', 'T'}). In this case, scanning the entire string might be prohibitively expensive. A possible alternative might be to use - only the first k characters of the string, where</p><p>|S|<sup>k</sup> ≥ m ,</p><p>i.e., using the hash function</p><div class="equation"><a id="idp18169584"></a><p class="title"><strong>Equation 22.6. + only the first k characters of the string, where</p><p>|S|<sup>k</sup> ≥ m ,</p><p>i.e., using the hash function</p><div class="equation"><a id="idp18169344"></a><p class="title"><strong>Equation 22.6. Only k String DNA Hash </strong></p><div class="equation-contents"><span class="mathphrase"> f<sub>2</sub>(s, m) = ∑ <sub>i @@ -606,12 +606,12 @@ the container transforms the key into a non-negative integral using the hash functor (points B and C), and transforms the result into a position using the combining functor (points D - and E).</p><div class="figure"><a id="idp18192144"></a><p class="title"><strong>Figure 22.15. Insert hash sequence diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_hash_range_hashing_seq_diagram.png" align="middle" alt="Insert hash sequence diagram" /></div></div></div><br class="figure-break" /><p>If <code class="classname">cc_hash_table</code>'s + and E).</p><div class="figure"><a id="idp18191968"></a><p class="title"><strong>Figure 22.15. Insert hash sequence diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_hash_range_hashing_seq_diagram.png" align="middle" alt="Insert hash sequence diagram" /></div></div></div><br class="figure-break" /><p>If <code class="classname">cc_hash_table</code>'s hash-functor, <code class="classname">Hash_Fn</code> is instantiated by <code class="classname">null_type</code> , then <code class="classname">Comb_Hash_Fn</code> is taken to be a ranged-hash function. The graphic below shows an <code class="function">insert</code> sequence diagram. The user inserts an element (point A), the container transforms the key into a position using the combining functor - (points B and C).</p><div class="figure"><a id="idp18199200"></a><p class="title"><strong>Figure 22.16. Insert hash sequence diagram with a null policy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_hash_range_hashing_seq_diagram2.png" align="middle" alt="Insert hash sequence diagram with a null policy" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="hash_policies.implementation.probe"></a> + (points B and C).</p><div class="figure"><a id="idp18199024"></a><p class="title"><strong>Figure 22.16. Insert hash sequence diagram with a null policy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_hash_range_hashing_seq_diagram2.png" align="middle" alt="Insert hash sequence diagram with a null policy" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="hash_policies.implementation.probe"></a> Probing tables </h6></div></div></div><p><code class="classname">gp_hash_table</code> is parametrized by <code class="classname">Hash_Fn</code>, <code class="classname">Probe_Fn</code>, @@ -634,7 +634,7 @@ a linear probe and a quadratic probe function, respectively.</p></li></ol></div><p> The graphic below shows the relationships. - </p><div class="figure"><a id="idp18215888"></a><p class="title"><strong>Figure 22.17. Hash policy class diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_hash_policy_cd.png" align="middle" alt="Hash policy class diagram" /></div></div></div><br class="figure-break" /></div></div></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.hash.details.resize_policies"></a>Resize Policies</h6></div></div></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="resize_policies.general"></a>General</h6></div></div></div><p>Hash-tables, as opposed to trees, do not naturally grow or + </p><div class="figure"><a id="idp18215840"></a><p class="title"><strong>Figure 22.17. Hash policy class diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_hash_policy_cd.png" align="middle" alt="Hash policy class diagram" /></div></div></div><br class="figure-break" /></div></div></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.hash.details.resize_policies"></a>Resize Policies</h6></div></div></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="resize_policies.general"></a>General</h6></div></div></div><p>Hash-tables, as opposed to trees, do not naturally grow or shrink. It is necessary to specify policies to determine how and when a hash table should change its size. Usually, resize policies can be decomposed into orthogonal policies:</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p>A size policy indicating how a hash table @@ -667,10 +667,10 @@ and some load factor be denoted by Α. We would like to calculate the minimal length of k, such that if there were Α m elements in the hash table, a probe sequence of length k would - be found with probability at most 1/m.</p><div class="figure"><a id="idp18234992"></a><p class="title"><strong>Figure 22.18. Balls and bins</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_balls_and_bins.png" align="middle" alt="Balls and bins" /></div></div></div><br class="figure-break" /><p>Denote the probability that a probe sequence of length + be found with probability at most 1/m.</p><div class="figure"><a id="idp18234944"></a><p class="title"><strong>Figure 22.18. Balls and bins</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_balls_and_bins.png" align="middle" alt="Balls and bins" /></div></div></div><br class="figure-break" /><p>Denote the probability that a probe sequence of length k appears in bin i by p<sub>i</sub>, the length of the probe sequence of bin i by - l<sub>i</sub>, and assume uniform distribution. Then</p><div class="equation"><a id="idp18240496"></a><p class="title"><strong>Equation 22.7. + l<sub>i</sub>, and assume uniform distribution. Then</p><div class="equation"><a id="idp18240448"></a><p class="title"><strong>Equation 22.7. Probability of Probe Sequence of Length k </strong></p><div class="equation-contents"><span class="mathphrase"> p<sub>1</sub> = @@ -684,7 +684,7 @@ l<sub>i</sub> are negatively-dependent (<a class="xref" href="policy_data_structures.html#biblio.dubhashi98neg" title="Balls and bins: A study in negative dependence">[biblio.dubhashi98neg]</a>) . Let - I(.) denote the indicator function. Then</p><div class="equation"><a id="idp18247264"></a><p class="title"><strong>Equation 22.8. + I(.) denote the indicator function. Then</p><div class="equation"><a id="idp18247216"></a><p class="title"><strong>Equation 22.8. Probability Probe Sequence in Some Bin </strong></p><div class="equation-contents"><span class="mathphrase"> P( exists<sub>i</sub> l<sub>i</sub> ≥ k ) = @@ -723,7 +723,7 @@ a resize is needed, and if so, what is the new size (points D to G); following the resize, it notifies the policy that a resize has completed (point H); finally, the element is - inserted, and the policy notified (point I).</p><div class="figure"><a id="idp18265776"></a><p class="title"><strong>Figure 22.19. Insert resize sequence diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_insert_resize_sequence_diagram1.png" align="middle" alt="Insert resize sequence diagram" /></div></div></div><br class="figure-break" /><p>In practice, a resize policy can be usually orthogonally + inserted, and the policy notified (point I).</p><div class="figure"><a id="idp18265728"></a><p class="title"><strong>Figure 22.19. Insert resize sequence diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_insert_resize_sequence_diagram1.png" align="middle" alt="Insert resize sequence diagram" /></div></div></div><br class="figure-break" /><p>In practice, a resize policy can be usually orthogonally decomposed to a size policy and a trigger policy. Consequently, the library contains a single class for instantiating a resize policy: <code class="classname">hash_standard_resize_policy</code> @@ -732,8 +732,8 @@ both, and acts as a standard delegate (<a class="xref" href="policy_data_structures.html#biblio.gof" title="Design Patterns - Elements of Reusable Object-Oriented Software">[biblio.gof]</a>) to these policies.</p><p>The two graphics immediately below show sequence diagrams illustrating the interaction between the standard resize policy - and its trigger and size policies, respectively.</p><div class="figure"><a id="idp18273552"></a><p class="title"><strong>Figure 22.20. Standard resize policy trigger sequence - diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_insert_resize_sequence_diagram2.png" align="middle" alt="Standard resize policy trigger sequence diagram" /></div></div></div><br class="figure-break" /><div class="figure"><a id="idp18277712"></a><p class="title"><strong>Figure 22.21. Standard resize policy size sequence + and its trigger and size policies, respectively.</p><div class="figure"><a id="idp18273504"></a><p class="title"><strong>Figure 22.20. Standard resize policy trigger sequence + diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_insert_resize_sequence_diagram2.png" align="middle" alt="Standard resize policy trigger sequence diagram" /></div></div></div><br class="figure-break" /><div class="figure"><a id="idp18277664"></a><p class="title"><strong>Figure 22.21. Standard resize policy size sequence diagram</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_insert_resize_sequence_diagram3.png" align="middle" alt="Standard resize policy size sequence diagram" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="resize_policies.impl.predefined"></a>Predefined Policies</h6></div></div></div><p>The library includes the following instantiations of size and trigger policies:</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p><code class="classname">hash_load_check_resize_trigger</code> implements a load check trigger policy.</p></li><li class="listitem"><p><code class="classname">cc_hash_max_collision_check_resize_trigger</code> @@ -876,7 +876,7 @@ each node, and maintains node invariants (see <a class="xref" href="policy_data_structures.html#biblio.clrs2001" title="Introduction to Algorithms, 2nd edition">[biblio.clrs2001]</a>.) The first stores in each node the size of the sub-tree rooted at the node; the second stores at each node the maximal endpoint of the - intervals at the sub-tree rooted at the node.</p><div class="figure"><a id="idp18355632"></a><p class="title"><strong>Figure 22.22. Tree node invariants</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_tree_node_invariants.png" align="middle" alt="Tree node invariants" /></div></div></div><br class="figure-break" /><p>Supporting such trees is difficult for a number of + intervals at the sub-tree rooted at the node.</p><div class="figure"><a id="idp18355696"></a><p class="title"><strong>Figure 22.22. Tree node invariants</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_tree_node_invariants.png" align="middle" alt="Tree node invariants" /></div></div></div><br class="figure-break" /><p>Supporting such trees is difficult for a number of reasons:</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p>There must be a way to specify what a node's metadata should be (if any).</p></li><li class="listitem"><p>Various operations can invalidate node invariants. The graphic below shows how a right rotation, @@ -890,7 +890,7 @@ metadata.</p></li><li class="listitem"><p>It is not feasible to know in advance which methods trees can support. Besides the usual <code class="classname">find</code> method, the first tree can support a <code class="classname">find_by_order</code> method, while - the second can support an <code class="classname">overlaps</code> method.</p></li></ol></div><div class="figure"><a id="idp18365072"></a><p class="title"><strong>Figure 22.23. Tree node invalidation</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_tree_node_invalidations.png" align="middle" alt="Tree node invalidation" /></div></div></div><br class="figure-break" /><p>These problems are solved by a combination of two means: + the second can support an <code class="classname">overlaps</code> method.</p></li></ol></div><div class="figure"><a id="idp18365136"></a><p class="title"><strong>Figure 22.23. Tree node invalidation</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_tree_node_invalidations.png" align="middle" alt="Tree node invalidation" /></div></div></div><br class="figure-break" /><p>These problems are solved by a combination of two means: node iterators, and template-template node updater parameters.</p><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.tree.node.iterators"></a>Node Iterators</h6></div></div></div><p>Each tree-based container defines two additional iterator types, <code class="classname">const_node_iterator</code> @@ -919,7 +919,7 @@ <code class="classname">node_update</code> class, and publicly subclasses <code class="classname">node_update</code>. The graphic below shows this scheme, as well as some predefined policies (which are explained - below).</p><div class="figure"><a id="idp18378176"></a><p class="title"><strong>Figure 22.24. A tree and its update policy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_tree_node_updator_policy_cd.png" align="middle" alt="A tree and its update policy" /></div></div></div><br class="figure-break" /><p><code class="classname">node_update</code> (an instantiation of + below).</p><div class="figure"><a id="idp18378304"></a><p class="title"><strong>Figure 22.24. A tree and its update policy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_tree_node_updator_policy_cd.png" align="middle" alt="A tree and its update policy" /></div></div></div><br class="figure-break" /><p><code class="classname">node_update</code> (an instantiation of <code class="classname">Node_Update</code>) must define <code class="classname">metadata_type</code> as the type of metadata it requires. For order statistics, e.g., <code class="classname">metadata_type</code> might be <code class="classname">size_t</code>. @@ -938,7 +938,7 @@ <code class="classname">nd_it</code>. For example, say node x in the graphic below label A has an invalid invariant, but its' children, y and z have valid invariants. After the invocation, all three - nodes should have valid invariants, as in label B.</p><div class="figure"><a id="idp18389840"></a><p class="title"><strong>Figure 22.25. Restoring node invariants</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_restoring_node_invariants.png" align="middle" alt="Restoring node invariants" /></div></div></div><br class="figure-break" /><p>When a tree operation might invalidate some node invariant, + nodes should have valid invariants, as in label B.</p><div class="figure"><a id="idp18389968"></a><p class="title"><strong>Figure 22.25. Restoring node invariants</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_restoring_node_invariants.png" align="middle" alt="Restoring node invariants" /></div></div></div><br class="figure-break" /><p>When a tree operation might invalidate some node invariant, it invokes this method in its <code class="classname">node_update</code> base to restore the invariant. For example, the graphic below shows an <code class="function">insert</code> operation (point A); the tree performs some @@ -946,7 +946,7 @@ C, and D). (It is well known that any <code class="function">insert</code>, <code class="function">erase</code>, <code class="function">split</code> or <code class="function">join</code>, can restore all node invariants by a small number of node invariant updates (<a class="xref" href="policy_data_structures.html#biblio.clrs2001" title="Introduction to Algorithms, 2nd edition">[biblio.clrs2001]</a>) - .</p><div class="figure"><a id="idp18398016"></a><p class="title"><strong>Figure 22.26. Insert update sequence</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_update_seq_diagram.png" align="middle" alt="Insert update sequence" /></div></div></div><br class="figure-break" /><p>To complete the description of the scheme, three questions + .</p><div class="figure"><a id="idp18398144"></a><p class="title"><strong>Figure 22.26. Insert update sequence</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_update_seq_diagram.png" align="middle" alt="Insert update sequence" /></div></div></div><br class="figure-break" /><p>To complete the description of the scheme, three questions need to be answered:</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p>How can a tree which supports order statistics define a method such as <code class="classname">find_by_order</code>?</p></li><li class="listitem"><p>How can the node updater base access methods of the tree?</p></li><li class="listitem"><p>How can the following cyclic dependency be resolved? @@ -988,7 +988,7 @@ node's metadata (this is halting reducible). In the graphic below, assume the shaded node is inserted. The tree would have to traverse the useless path shown to the root, applying - redundant updates all the way.</p></li></ol></div><div class="figure"><a id="idp18420272"></a><p class="title"><strong>Figure 22.27. Useless update path</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_rationale_null_node_updator.png" align="middle" alt="Useless update path" /></div></div></div><br class="figure-break" /><p>A null policy class, <code class="classname">null_node_update</code> + redundant updates all the way.</p></li></ol></div><div class="figure"><a id="idp18420400"></a><p class="title"><strong>Figure 22.27. Useless update path</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_rationale_null_node_updator.png" align="middle" alt="Useless update path" /></div></div></div><br class="figure-break" /><p>A null policy class, <code class="classname">null_node_update</code> solves both these problems. The tree detects that node invariants are irrelevant, and defines all accordingly.</p></div></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.tree.details.split"></a>Split and Join</h6></div></div></div><p>Tree-based containers support split and join methods. It is possible to split a tree so that it passes @@ -1071,7 +1071,7 @@ sub-tree with leafs "a" and "as". The maximal common prefix is "a". The internal node contains, consequently, to const iterators, one pointing to <code class="varname">'a'</code>, and the other to - <code class="varname">'s'</code>.</p><div class="figure"><a id="idp18465024"></a><p class="title"><strong>Figure 22.28. A PATRICIA trie</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_pat_trie.png" align="middle" alt="A PATRICIA trie" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.trie.details.node"></a>Node Invariants</h6></div></div></div><p>Trie-based containers support node invariants, as do + <code class="varname">'s'</code>.</p><div class="figure"><a id="idp18465088"></a><p class="title"><strong>Figure 22.28. A PATRICIA trie</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_pat_trie.png" align="middle" alt="A PATRICIA trie" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.trie.details.node"></a>Node Invariants</h6></div></div></div><p>Trie-based containers support node invariants, as do tree-based containers. There are two minor differences, though, which, unfortunately, thwart sharing them sharing the same node-updating policies:</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p>A trie's <code class="classname">Node_Update</code> template-template @@ -1080,7 +1080,7 @@ parametrized by <code class="classname">Cmp_Fn</code>.</p></li><li class="listitem"><p>Tree-based containers store values in all nodes, while trie-based containers (at least in this implementation) store values in leafs.</p></li></ol></div><p>The graphic below shows the scheme, as well as some predefined - policies (which are explained below).</p><div class="figure"><a id="idp18475456"></a><p class="title"><strong>Figure 22.29. A trie and its update policy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_trie_node_updator_policy_cd.png" align="middle" alt="A trie and its update policy" /></div></div></div><br class="figure-break" /><p>This library offers the following pre-defined trie node + policies (which are explained below).</p><div class="figure"><a id="idp18475584"></a><p class="title"><strong>Figure 22.29. A trie and its update policy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_trie_node_updator_policy_cd.png" align="middle" alt="A trie and its update policy" /></div></div></div><br class="figure-break" /><p>This library offers the following pre-defined trie node updating policies:</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p> <code class="classname">trie_order_statistics_node_update</code> supports order statistics. @@ -1128,7 +1128,7 @@ simple list of integer keys. If we search for the integer 6, we are paying an overhead: the link with key 6 is only the fifth link; if it were the first link, it could be accessed - faster.</p><div class="figure"><a id="idp18505968"></a><p class="title"><strong>Figure 22.30. A simple list</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_simple_list.png" align="middle" alt="A simple list" /></div></div></div><br class="figure-break" /><p>List-update algorithms reorder lists as elements are + faster.</p><div class="figure"><a id="idp18506160"></a><p class="title"><strong>Figure 22.30. A simple list</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_simple_list.png" align="middle" alt="A simple list" /></div></div></div><br class="figure-break" /><p>List-update algorithms reorder lists as elements are accessed. They try to determine, by the access history, which keys to move to the front of the list. Some of these algorithms require adding some metadata alongside each entry.</p><p>For example, in the graphic below label A shows the counter @@ -1138,7 +1138,7 @@ predetermined value, say 10, as shown in label C, the count is set to 0 and the node is moved to the front of the list, as in label D. - </p><div class="figure"><a id="idp18511552"></a><p class="title"><strong>Figure 22.31. The counter algorithm</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_list_update.png" align="middle" alt="The counter algorithm" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.list.details.policies"></a>Policies</h6></div></div></div><p>this library allows instantiating lists with policies + </p><div class="figure"><a id="idp18511744"></a><p class="title"><strong>Figure 22.31. The counter algorithm</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_list_update.png" align="middle" alt="The counter algorithm" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h6 class="title"><a id="container.list.details.policies"></a>Policies</h6></div></div></div><p>this library allows instantiating lists with policies implementing any algorithm moving nodes to the front of the list (policies implementing algorithms interchanging nodes are unsupported).</p><p>Associative containers based on lists are parametrized by a @@ -1310,7 +1310,7 @@ sequence; the second uses a tree (or forest of trees), which is typically less structured than an associative container's tree; the third simply uses an associative container. These are - shown in the graphic below, in labels A1 and A2, label B, and label C.</p><div class="figure"><a id="idp18575312"></a><p class="title"><strong>Figure 22.32. Underlying Priority-Queue Data-Structures.</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_priority_queue_different_underlying_dss.png" align="middle" alt="Underlying Priority-Queue Data-Structures." /></div></div></div><br class="figure-break" /><p>Roughly speaking, any value that is both pushed and popped + shown in the graphic below, in labels A1 and A2, label B, and label C.</p><div class="figure"><a id="idp18575568"></a><p class="title"><strong>Figure 22.32. Underlying Priority-Queue Data-Structures.</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_priority_queue_different_underlying_dss.png" align="middle" alt="Underlying Priority-Queue Data-Structures." /></div></div></div><br class="figure-break" /><p>Roughly speaking, any value that is both pushed and popped from a priority queue must incur a logarithmic expense (in the amortized sense). Any priority queue implementation that would avoid this, would violate known bounds on comparison-based @@ -1390,7 +1390,7 @@ container <code class="classname">Cntnr</code>, the tag of the underlying data structure can be found via <code class="classname">typename Cntnr::container_category</code>; this is one of the possible tags shown in the graphic below. - </p><div class="figure"><a id="idp18610288"></a><p class="title"><strong>Figure 22.33. Priority-Queue Data-Structure Tags.</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_priority_queue_tag_hierarchy.png" align="middle" alt="Priority-Queue Data-Structure Tags." /></div></div></div><br class="figure-break" /><p>Additionally, a traits mechanism can be used to query a + </p><div class="figure"><a id="idp18610544"></a><p class="title"><strong>Figure 22.33. Priority-Queue Data-Structure Tags.</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_priority_queue_tag_hierarchy.png" align="middle" alt="Priority-Queue Data-Structure Tags." /></div></div></div><br class="figure-break" /><p>Additionally, a traits mechanism can be used to query a container type for its attributes. Given any container <code class="classname">Cntnr</code>, then </p><pre class="programlisting">__gnu_pbds::container_traits<Cntnr></pre><p> is a traits class identifying the properties of the diff --git a/libstdc++-v3/doc/html/manual/policy_data_structures_using.html b/libstdc++-v3/doc/html/manual/policy_data_structures_using.html index 0cbc196f9ae..fec178fa1a2 100644 --- a/libstdc++-v3/doc/html/manual/policy_data_structures_using.html +++ b/libstdc++-v3/doc/html/manual/policy_data_structures_using.html @@ -61,7 +61,7 @@ In addition, there are the following diagnostics classes, used to report errors specific to this library's data structures. - </p><div class="figure"><a id="idp17806560"></a><p class="title"><strong>Figure 22.7. Exception Hierarchy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_exception_hierarchy.png" align="middle" alt="Exception Hierarchy" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="pbds.using.tutorial"></a>Tutorial</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="pbds.using.tutorial.basic"></a>Basic Use</h4></div></div></div><p> + </p><div class="figure"><a id="idp17806128"></a><p class="title"><strong>Figure 22.7. Exception Hierarchy</strong></p><div class="figure-contents"><div class="mediaobject" align="center"><img src="../images/pbds_exception_hierarchy.png" align="middle" alt="Exception Hierarchy" /></div></div></div><br class="figure-break" /></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="pbds.using.tutorial"></a>Tutorial</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="pbds.using.tutorial.basic"></a>Basic Use</h4></div></div></div><p> For the most part, the policy-based containers containers in namespace <code class="literal">__gnu_pbds</code> have the same interface as the equivalent containers in the standard C++ library, except for diff --git a/libstdc++-v3/doc/html/manual/profile_mode.html b/libstdc++-v3/doc/html/manual/profile_mode.html index e44421c6e0d..55778294f6b 100644 --- a/libstdc++-v3/doc/html/manual/profile_mode.html +++ b/libstdc++-v3/doc/html/manual/profile_mode.html @@ -137,7 +137,7 @@ vector-size: improvement = 3: call stack = 0x804842c ... call context. (Environment variable not supported.) </p></li></ul></div><p> - </p></div></div><div class="bibliography"><div class="titlepage"><div><div><h2 class="title"><a id="profile_mode.biblio"></a>Bibliography</h2></div></div></div><div class="biblioentry"><a id="idp17395648"></a><p><span class="citetitle"><em class="citetitle"> + </p></div></div><div class="bibliography"><div class="titlepage"><div><div><h2 class="title"><a id="profile_mode.biblio"></a>Bibliography</h2></div></div></div><div class="biblioentry"><a id="idp17395456"></a><p><span class="citetitle"><em class="citetitle"> Perflint: A Context Sensitive Performance Advisor for C++ Programs </em>. </span><span class="author"><span class="firstname">Lixia</span> <span class="surname">Liu</span>. </span><span class="author"><span class="firstname">Silvius</span> <span class="surname">Rus</span>. </span><span class="copyright">Copyright © 2009 . </span><span class="publisher"><span class="publishername"> Proceedings of the 2009 International Symposium on Code Generation diff --git a/libstdc++-v3/doc/html/manual/profile_mode_design.html b/libstdc++-v3/doc/html/manual/profile_mode_design.html index 7f5e1fab7f5..69119bf0135 100644 --- a/libstdc++-v3/doc/html/manual/profile_mode_design.html +++ b/libstdc++-v3/doc/html/manual/profile_mode_design.html @@ -1,6 +1,6 @@ <?xml version="1.0" encoding="UTF-8" standalone="no"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Design</title><meta name="generator" content="DocBook XSL-NS Stylesheets V1.77.1" /><meta name="keywords" content="C++, library, profile" /><meta name="keywords" content="ISO C++, library" /><meta name="keywords" content="ISO C++, runtime, library" /><link rel="home" href="../index.html" title="The GNU C++ Library" /><link rel="up" href="profile_mode.html" title="Chapter 19. Profile Mode" /><link rel="prev" href="profile_mode.html" title="Chapter 19. Profile Mode" /><link rel="next" href="profile_mode_api.html" title="Extensions for Custom Containers" /></head><body><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Design</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="profile_mode.html">Prev</a> </td><th width="60%" align="center">Chapter 19. Profile Mode</th><td width="20%" align="right"> <a accesskey="n" href="profile_mode_api.html">Next</a></td></tr></table><hr /></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="manual.ext.profile_mode.design"></a>Design</h2></div></div></div><p> -</p><div class="table"><a id="idp16981328"></a><p class="title"><strong>Table 19.1. Profile Code Location</strong></p><div class="table-contents"><table summary="Profile Code Location" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">Code Location</th><th align="left">Use</th></tr></thead><tbody><tr><td align="left"><code class="code">libstdc++-v3/include/std/*</code></td><td align="left">Preprocessor code to redirect to profile extension headers.</td></tr><tr><td align="left"><code class="code">libstdc++-v3/include/profile/*</code></td><td align="left">Profile extension public headers (map, vector, ...).</td></tr><tr><td align="left"><code class="code">libstdc++-v3/include/profile/impl/*</code></td><td align="left">Profile extension internals. Implementation files are +</p><div class="table"><a id="idp16981200"></a><p class="title"><strong>Table 19.1. Profile Code Location</strong></p><div class="table-contents"><table summary="Profile Code Location" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">Code Location</th><th align="left">Use</th></tr></thead><tbody><tr><td align="left"><code class="code">libstdc++-v3/include/std/*</code></td><td align="left">Preprocessor code to redirect to profile extension headers.</td></tr><tr><td align="left"><code class="code">libstdc++-v3/include/profile/*</code></td><td align="left">Profile extension public headers (map, vector, ...).</td></tr><tr><td align="left"><code class="code">libstdc++-v3/include/profile/impl/*</code></td><td align="left">Profile extension internals. Implementation files are only included from <code class="code">impl/profiler.h</code>, which is the only file included from the public headers.</td></tr></tbody></table></div></div><br class="table-break" /><p> </p><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="manual.ext.profile_mode.design.wrapper"></a>Wrapper Model</h3></div></div></div><p> diff --git a/libstdc++-v3/doc/html/manual/profile_mode_diagnostics.html b/libstdc++-v3/doc/html/manual/profile_mode_diagnostics.html index bc72c2d964d..4b68fbeaa69 100644 --- a/libstdc++-v3/doc/html/manual/profile_mode_diagnostics.html +++ b/libstdc++-v3/doc/html/manual/profile_mode_diagnostics.html @@ -17,7 +17,7 @@ A high accuracy means that the diagnostic is unlikely to be wrong. These grades are not perfect. They are just meant to guide users with specific needs or time budgets. - </p><div class="table"><a id="idp17088784"></a><p class="title"><strong>Table 19.2. Profile Diagnostics</strong></p><div class="table-contents"><table summary="Profile Diagnostics" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /><col align="left" class="c6" /><col align="left" class="c7" /></colgroup><thead><tr><th align="left">Group</th><th align="left">Flag</th><th align="left">Benefit</th><th align="left">Cost</th><th align="left">Freq.</th><th align="left">Implemented</th><td class="auto-generated"> </td></tr></thead><tbody><tr><td align="left"><a class="link" href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.containers" title="Containers"> + </p><div class="table"><a id="idp17088912"></a><p class="title"><strong>Table 19.2. Profile Diagnostics</strong></p><div class="table-contents"><table summary="Profile Diagnostics" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /><col align="left" class="c6" /><col align="left" class="c7" /></colgroup><thead><tr><th align="left">Group</th><th align="left">Flag</th><th align="left">Benefit</th><th align="left">Cost</th><th align="left">Freq.</th><th align="left">Implemented</th><td class="auto-generated"> </td></tr></thead><tbody><tr><td align="left"><a class="link" href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.containers" title="Containers"> CONTAINERS</a></td><td align="left"><a class="link" href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.hashtable_too_small" title="Hashtable Too Small"> HASHTABLE_TOO_SMALL</a></td><td align="left">10</td><td align="left">1</td><td align="left"> </td><td align="left">10</td><td align="left">yes</td></tr><tr><td align="left"> </td><td align="left"><a class="link" href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.hashtable_too_large" title="Hashtable Too Large"> HASHTABLE_TOO_LARGE</a></td><td align="left">5</td><td align="left">1</td><td align="left"> </td><td align="left">10</td><td align="left">yes</td></tr><tr><td align="left"> </td><td align="left"><a class="link" href="profile_mode_diagnostics.html#manual.ext.profile_mode.analysis.inefficient_hash" title="Inefficient Hash"> diff --git a/libstdc++-v3/doc/html/manual/status.html b/libstdc++-v3/doc/html/manual/status.html index 81d45cf07f7..7019525382d 100644 --- a/libstdc++-v3/doc/html/manual/status.html +++ b/libstdc++-v3/doc/html/manual/status.html @@ -7,7 +7,7 @@ This status table is based on the table of contents of ISO/IEC 14882:2003. </p><p> This page describes the C++ support in mainline GCC SVN, not in any particular release. -</p><div class="table"><a id="idp1142240"></a><p class="title"><strong>Table 1.1. C++ 1998/2003 Implementation Status</strong></p><div class="table-contents"><table summary="C++ 1998/2003 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> +</p><div class="table"><a id="idp452240"></a><p class="title"><strong>Table 1.1. C++ 1998/2003 Implementation Status</strong></p><div class="table-contents"><table summary="C++ 1998/2003 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> <span class="emphasis"><em>18</em></span> </td><td colspan="3" align="left"> <span class="emphasis"><em>Language support</em></span> @@ -157,7 +157,7 @@ presence of the required flag. </p><p> This page describes the C++11 support in mainline GCC SVN, not in any particular release. -</p><div class="table"><a id="idp9027792"></a><p class="title"><strong>Table 1.2. C++ 2011 Implementation Status</strong></p><div class="table-contents"><table summary="C++ 2011 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> +</p><div class="table"><a id="idp8670848"></a><p class="title"><strong>Table 1.2. C++ 2011 Implementation Status</strong></p><div class="table-contents"><table summary="C++ 2011 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> <span class="emphasis"><em>18</em></span> </td><td colspan="3" align="left"> <span class="emphasis"><em>Language support</em></span> @@ -302,7 +302,7 @@ In this implementation the header names are prefixed by </p><p> This page describes the TR1 support in mainline GCC SVN, not in any particular release. -</p><div class="table"><a id="idp8179360"></a><p class="title"><strong>Table 1.3. C++ TR1 Implementation Status</strong></p><div class="table-contents"><table summary="C++ TR1 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"><span class="emphasis"><em>2</em></span></td><td colspan="3" align="left"><span class="emphasis"><em>General Utilities</em></span></td></tr><tr><td align="left">2.1</td><td align="left">Reference wrappers</td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.1.1</td><td align="left">Additions to header <code class="code"><functional></code> synopsis</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2</td><td align="left">Class template <code class="code">reference_wrapper</code></td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.1.2.1</td><td align="left"><code class="code">reference_wrapper</code> construct/copy/destroy</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.2</td><td align="left"><code class="code">reference_wrapper</code> assignment</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.3</td><td align="left"><code class="code">reference_wrapper</code> access</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.4</td><td align="left"><code class="code">reference_wrapper</code> invocation</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.5</td><td align="left"><code class="code">reference_wrapper</code> helper functions</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2</td><td align="left">Smart pointers</td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.2.1</td><td align="left">Additions to header <code class="code"><memory></code> synopsis</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2.2</td><td align="left">Class <code class="code">bad_weak_ptr</code></td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2.3</td><td align="left">Class template <code class="code">shared_ptr</code></td><td align="left"> </td><td align="left"> +</p><div class="table"><a id="idp7483200"></a><p class="title"><strong>Table 1.3. C++ TR1 Implementation Status</strong></p><div class="table-contents"><table summary="C++ TR1 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"><span class="emphasis"><em>2</em></span></td><td colspan="3" align="left"><span class="emphasis"><em>General Utilities</em></span></td></tr><tr><td align="left">2.1</td><td align="left">Reference wrappers</td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.1.1</td><td align="left">Additions to header <code class="code"><functional></code> synopsis</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2</td><td align="left">Class template <code class="code">reference_wrapper</code></td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.1.2.1</td><td align="left"><code class="code">reference_wrapper</code> construct/copy/destroy</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.2</td><td align="left"><code class="code">reference_wrapper</code> assignment</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.3</td><td align="left"><code class="code">reference_wrapper</code> access</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.4</td><td align="left"><code class="code">reference_wrapper</code> invocation</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.5</td><td align="left"><code class="code">reference_wrapper</code> helper functions</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2</td><td align="left">Smart pointers</td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.2.1</td><td align="left">Additions to header <code class="code"><memory></code> synopsis</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2.2</td><td align="left">Class <code class="code">bad_weak_ptr</code></td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2.3</td><td align="left">Class template <code class="code">shared_ptr</code></td><td align="left"> </td><td align="left"> <p> Uses code from <a class="link" href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm" target="_top">boost::shared_ptr</a>. @@ -323,7 +323,7 @@ decimal floating-point arithmetic </p><p> This page describes the TR 24733 support in mainline GCC SVN, not in any particular release. -</p><div class="table"><a id="idp12556688"></a><p class="title"><strong>Table 1.4. C++ TR 24733 Implementation Status</strong></p><div class="table-contents"><table summary="C++ TR 24733 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> +</p><div class="table"><a id="idp12559072"></a><p class="title"><strong>Table 1.4. C++ TR 24733 Implementation Status</strong></p><div class="table-contents"><table summary="C++ TR 24733 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> <span class="emphasis"><em>0</em></span> </td><td colspan="3" align="left"> <span class="emphasis"><em>Introduction</em></span> diff --git a/libstdc++-v3/doc/html/manual/std_contents.html b/libstdc++-v3/doc/html/manual/std_contents.html index 88a703ef677..b8c889310e0 100644 --- a/libstdc++-v3/doc/html/manual/std_contents.html +++ b/libstdc++-v3/doc/html/manual/std_contents.html @@ -12,13 +12,13 @@ </a></span></dt><dd><dl><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions">Exceptions</a></span></dt><dd><dl><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions.api">API Reference</a></span></dt><dt><span class="section"><a href="diagnostics.html#std.diagnostics.exceptions.data">Adding Data to <code class="classname">exception</code></a></span></dt></dl></dd><dt><span class="section"><a href="concept_checking.html">Concept Checking</a></span></dt></dl></dd><dt><span class="chapter"><a href="utilities.html">6. Utilities -</a></span></dt><dd><dl><dt><span class="section"><a href="utilities.html#std.util.functors">Functors</a></span></dt><dt><span class="section"><a href="pairs.html">Pairs</a></span></dt><dt><span class="section"><a href="memory.html">Memory</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#std.util.memory.allocator">Allocators</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#allocator.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#allocator.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#allocator.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp13918736">Interface Design</a></span></dt><dt><span class="section"><a href="memory.html#idp13922288">Selecting Default Allocation Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp13935584">Disabling Memory Caching</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#allocator.using">Using a Specific Allocator</a></span></dt><dt><span class="section"><a href="memory.html#allocator.custom">Custom Allocators</a></span></dt><dt><span class="section"><a href="memory.html#allocator.ext">Extension Allocators</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.auto_ptr">auto_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#auto_ptr.limitations">Limitations</a></span></dt><dt><span class="section"><a href="memory.html#auto_ptr.using">Use in Containers</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.shared_ptr">shared_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#shared_ptr.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15511664">Class Hierarchy</a></span></dt><dt><span class="section"><a href="memory.html#idp15534176">Thread Safety</a></span></dt><dt><span class="section"><a href="memory.html#idp15541472">Selecting Lock Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp15556096">Related functions and classes</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.using">Use</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15572448">Examples</a></span></dt><dt><span class="section"><a href="memory.html#idp15576032">Unresolved Issues</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.ack">Acknowledgments</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="traits.html">Traits</a></span></dt></dl></dd><dt><span class="chapter"><a href="strings.html">7. +</a></span></dt><dd><dl><dt><span class="section"><a href="utilities.html#std.util.functors">Functors</a></span></dt><dt><span class="section"><a href="pairs.html">Pairs</a></span></dt><dt><span class="section"><a href="memory.html">Memory</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#std.util.memory.allocator">Allocators</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#allocator.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#allocator.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#allocator.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp13920976">Interface Design</a></span></dt><dt><span class="section"><a href="memory.html#idp13924528">Selecting Default Allocation Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp13937824">Disabling Memory Caching</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#allocator.using">Using a Specific Allocator</a></span></dt><dt><span class="section"><a href="memory.html#allocator.custom">Custom Allocators</a></span></dt><dt><span class="section"><a href="memory.html#allocator.ext">Extension Allocators</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.auto_ptr">auto_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#auto_ptr.limitations">Limitations</a></span></dt><dt><span class="section"><a href="memory.html#auto_ptr.using">Use in Containers</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.shared_ptr">shared_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#shared_ptr.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15512272">Class Hierarchy</a></span></dt><dt><span class="section"><a href="memory.html#idp15534784">Thread Safety</a></span></dt><dt><span class="section"><a href="memory.html#idp15542080">Selecting Lock Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp15556704">Related functions and classes</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.using">Use</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15573056">Examples</a></span></dt><dt><span class="section"><a href="memory.html#idp15576640">Unresolved Issues</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.ack">Acknowledgments</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="traits.html">Traits</a></span></dt></dl></dd><dt><span class="chapter"><a href="strings.html">7. Strings </a></span></dt><dd><dl><dt><span class="section"><a href="strings.html#std.strings.string">String Classes</a></span></dt><dd><dl><dt><span class="section"><a href="strings.html#strings.string.simple">Simple Transformations</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.case">Case Sensitivity</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.character_types">Arbitrary Character Types</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.token">Tokenizing</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.shrink">Shrink to Fit</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.Cstring">CString (MFC)</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="localization.html">8. Localization -</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales">Locales</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales.locale">locale</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locales.locale.req">Requirements</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.design">Design</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locale.impl.c">Interacting with "C" locales</a></span></dt></dl></dd><dt><span class="section"><a href="localization.html#locales.locale.future">Future</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="facets.html">Facets</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#std.localization.facet.ctype">ctype</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.ctype.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#idp15777920">Specializations</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.ctype.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#std.localization.facet.codecvt">codecvt</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.codecvt.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.design">Design</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#codecvt.design.wchar_t_size"><span class="type">wchar_t</span> Size</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.unicode">Support for Unicode</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.issues">Other Issues</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.codecvt.impl">Implementation</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#manual.localization.facet.messages">messages</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.messages.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.design">Design</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#messages.impl.models">Models</a></span></dt><dt><span class="section"><a href="facets.html#messages.impl.gnu">The GNU Model</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.messages.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.future">Future</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="chapter"><a href="containers.html">9. +</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales">Locales</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#std.localization.locales.locale">locale</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locales.locale.req">Requirements</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.design">Design</a></span></dt><dt><span class="section"><a href="localization.html#locales.locale.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="localization.html#locale.impl.c">Interacting with "C" locales</a></span></dt></dl></dd><dt><span class="section"><a href="localization.html#locales.locale.future">Future</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="facets.html">Facets</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#std.localization.facet.ctype">ctype</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.ctype.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#idp15778336">Specializations</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.ctype.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#std.localization.facet.codecvt">codecvt</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.codecvt.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.design">Design</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#codecvt.design.wchar_t_size"><span class="type">wchar_t</span> Size</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.unicode">Support for Unicode</a></span></dt><dt><span class="section"><a href="facets.html#codecvt.design.issues">Other Issues</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.codecvt.impl">Implementation</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.codecvt.future">Future</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#manual.localization.facet.messages">messages</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#facet.messages.req">Requirements</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.design">Design</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="facets.html#messages.impl.models">Models</a></span></dt><dt><span class="section"><a href="facets.html#messages.impl.gnu">The GNU Model</a></span></dt></dl></dd><dt><span class="section"><a href="facets.html#facet.messages.use">Use</a></span></dt><dt><span class="section"><a href="facets.html#facet.messages.future">Future</a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="chapter"><a href="containers.html">9. Containers </a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#std.containers.sequences">Sequences</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#containers.sequences.list">list</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#sequences.list.size">list::size() is O(n)</a></span></dt></dl></dd><dt><span class="section"><a href="containers.html#containers.sequences.vector">vector</a></span></dt><dd><dl><dt><span class="section"><a href="containers.html#sequences.vector.management">Space Overhead Management</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="associative.html">Associative</a></span></dt><dd><dl><dt><span class="section"><a href="associative.html#containers.associative.insert_hints">Insertion Hints</a></span></dt><dt><span class="section"><a href="associative.html#containers.associative.bitset">bitset</a></span></dt><dd><dl><dt><span class="section"><a href="associative.html#associative.bitset.size_variable">Size Variable</a></span></dt><dt><span class="section"><a href="associative.html#associative.bitset.type_string">Type String</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="unordered_associative.html">Unordered Associative</a></span></dt><dd><dl><dt><span class="section"><a href="unordered_associative.html#containers.unordered.hash">Hash Code</a></span></dt><dd><dl><dt><span class="section"><a href="unordered_associative.html#containers.unordered.cache">Hash Code Caching Policy</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="containers_and_c.html">Interacting with C</a></span></dt><dd><dl><dt><span class="section"><a href="containers_and_c.html#containers.c.vs_array">Containers vs. Arrays</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="iterators.html">10. diff --git a/libstdc++-v3/doc/html/manual/strings.html b/libstdc++-v3/doc/html/manual/strings.html index bbdfbdce17e..2f1e8410d64 100644 --- a/libstdc++-v3/doc/html/manual/strings.html +++ b/libstdc++-v3/doc/html/manual/strings.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="localization.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.strings"></a>Chapter 7. Strings - <a id="idp15602896" class="indexterm"></a> + <a id="idp15603440" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="strings.html#std.strings.string">String Classes</a></span></dt><dd><dl><dt><span class="section"><a href="strings.html#strings.string.simple">Simple Transformations</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.case">Case Sensitivity</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.character_types">Arbitrary Character Types</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.token">Tokenizing</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.shrink">Shrink to Fit</a></span></dt><dt><span class="section"><a href="strings.html#strings.string.Cstring">CString (MFC)</a></span></dt></dl></dd></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.strings.string"></a>String Classes</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="strings.string.simple"></a>Simple Transformations</h3></div></div></div><p> Here are Standard, simple, and portable ways to perform common transformations on a <code class="code">string</code> instance, such as diff --git a/libstdc++-v3/doc/html/manual/support.html b/libstdc++-v3/doc/html/manual/support.html index a685558a357..8d017a251dc 100644 --- a/libstdc++-v3/doc/html/manual/support.html +++ b/libstdc++-v3/doc/html/manual/support.html @@ -6,7 +6,7 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="dynamic_memory.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.support"></a>Chapter 4. Support - <a id="idp13743888" class="indexterm"></a> + <a id="idp13745936" class="indexterm"></a> </h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="support.html#std.support.types">Types</a></span></dt><dd><dl><dt><span class="section"><a href="support.html#std.support.types.fundamental">Fundamental Types</a></span></dt><dt><span class="section"><a href="support.html#std.support.types.numeric_limits">Numeric Properties</a></span></dt><dt><span class="section"><a href="support.html#std.support.types.null">NULL</a></span></dt></dl></dd><dt><span class="section"><a href="dynamic_memory.html">Dynamic Memory</a></span></dt><dt><span class="section"><a href="termination.html">Termination</a></span></dt><dd><dl><dt><span class="section"><a href="termination.html#support.termination.handlers">Termination Handlers</a></span></dt><dt><span class="section"><a href="termination.html#support.termination.verbose">Verbose Terminate Handler</a></span></dt></dl></dd></dl></div><p> This part deals with the functions called and objects created automatically during the course of a program's existence. diff --git a/libstdc++-v3/doc/html/manual/test.html b/libstdc++-v3/doc/html/manual/test.html index 222169ed15b..9e32a264186 100644 --- a/libstdc++-v3/doc/html/manual/test.html +++ b/libstdc++-v3/doc/html/manual/test.html @@ -492,7 +492,7 @@ only default variables. reporting functions including: </p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "><li class="listitem"><p>time_counter</p></li><li class="listitem"><p>resource_counter</p></li><li class="listitem"><p>report_performance</p></li></ul></div></li></ul></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="test.special"></a>Special Topics</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="test.exception.safety"></a> Qualifying Exception Safety Guarantees - <a id="idp22628480" class="indexterm"></a> + <a id="idp22628992" class="indexterm"></a> </h4></div></div></div><div class="section"><div class="titlepage"><div><div><h5 class="title"><a id="test.exception.safety.overview"></a>Overview</h5></div></div></div><p> Testing is composed of running a particular test sequence, and looking at what happens to the surrounding code when diff --git a/libstdc++-v3/doc/html/manual/using.html b/libstdc++-v3/doc/html/manual/using.html index 984577c5a35..259ed27dd67 100644 --- a/libstdc++-v3/doc/html/manual/using.html +++ b/libstdc++-v3/doc/html/manual/using.html @@ -10,5 +10,5 @@ enumerated and detailed in the table below. </p><p> By default, <span class="command"><strong>g++</strong></span> is equivalent to <span class="command"><strong>g++ -std=gnu++98</strong></span>. The standard library also defaults to this dialect. - </p><div class="table"><a id="idp13049824"></a><p class="title"><strong>Table 3.1. C++ Command Options</strong></p><div class="table-contents"><table summary="C++ Command Options" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">Option Flags</th><th align="left">Description</th></tr></thead><tbody><tr><td align="left"><code class="literal">-std=c++98</code></td><td align="left">Use the 1998 ISO C++ standard plus amendments.</td></tr><tr><td align="left"><code class="literal">-std=gnu++98</code></td><td align="left">As directly above, with GNU extensions.</td></tr><tr><td align="left"><code class="literal">-std=c++11</code></td><td align="left">Use the 2011 ISO C++ standard.</td></tr><tr><td align="left"><code class="literal">-std=gnu++11</code></td><td align="left">As directly above, with GNU extensions.</td></tr><tr><td align="left"><code class="literal">-fexceptions</code></td><td align="left">See <a class="link" href="using_exceptions.html#intro.using.exception.no" title="Doing without">exception-free dialect</a></td></tr><tr><td align="left"><code class="literal">-frtti</code></td><td align="left">As above, but RTTI-free dialect.</td></tr><tr><td align="left"><code class="literal">-pthread</code> or <code class="literal">-pthreads</code></td><td align="left">For ISO C++11 <thread>, <future>, + </p><div class="table"><a id="idp13051936"></a><p class="title"><strong>Table 3.1. C++ Command Options</strong></p><div class="table-contents"><table summary="C++ Command Options" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><thead><tr><th align="left">Option Flags</th><th align="left">Description</th></tr></thead><tbody><tr><td align="left"><code class="literal">-std=c++98</code></td><td align="left">Use the 1998 ISO C++ standard plus amendments.</td></tr><tr><td align="left"><code class="literal">-std=gnu++98</code></td><td align="left">As directly above, with GNU extensions.</td></tr><tr><td align="left"><code class="literal">-std=c++11</code></td><td align="left">Use the 2011 ISO C++ standard.</td></tr><tr><td align="left"><code class="literal">-std=gnu++11</code></td><td align="left">As directly above, with GNU extensions.</td></tr><tr><td align="left"><code class="literal">-fexceptions</code></td><td align="left">See <a class="link" href="using_exceptions.html#intro.using.exception.no" title="Doing without">exception-free dialect</a></td></tr><tr><td align="left"><code class="literal">-frtti</code></td><td align="left">As above, but RTTI-free dialect.</td></tr><tr><td align="left"><code class="literal">-pthread</code> or <code class="literal">-pthreads</code></td><td align="left">For ISO C++11 <thread>, <future>, <mutex>, or <condition_variable>.</td></tr><tr><td align="left"><code class="literal">-fopenmp</code></td><td align="left">For <a class="link" href="parallel_mode.html" title="Chapter 18. Parallel Mode">parallel</a> mode.</td></tr></tbody></table></div></div><br class="table-break" /></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="make.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="intro.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="using_headers.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Make </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Headers</td></tr></table></div></body></html>
\ No newline at end of file diff --git a/libstdc++-v3/doc/html/manual/using_exceptions.html b/libstdc++-v3/doc/html/manual/using_exceptions.html index c4dafc0c060..b1451c66e19 100644 --- a/libstdc++-v3/doc/html/manual/using_exceptions.html +++ b/libstdc++-v3/doc/html/manual/using_exceptions.html @@ -265,7 +265,7 @@ is called. } catch(...) { this->_M_setstate(ios_base::badbit); } -</pre></div></div><div class="bibliography"><div class="titlepage"><div><div><h3 class="title"><a id="using.exceptions.biblio"></a>Bibliography</h3></div></div></div><div class="biblioentry"><a id="idp13641888"></a><p><span class="title"><em> +</pre></div></div><div class="bibliography"><div class="titlepage"><div><div><h3 class="title"><a id="using.exceptions.biblio"></a>Bibliography</h3></div></div></div><div class="biblioentry"><a id="idp13644000"></a><p><span class="title"><em> <a class="link" href="http://www.opengroup.org/austin/" target="_top"> System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) </a> @@ -274,39 +274,39 @@ is called. . </span><span class="copyright">Copyright © 2008 The Open Group/The Institute of Electrical and Electronics Engineers, Inc. - . </span></p></div><div class="biblioentry"><a id="idp13645584"></a><p><span class="title"><em> + . </span></p></div><div class="biblioentry"><a id="idp13647696"></a><p><span class="title"><em> <a class="link" href="http://www.boost.org/community/error_handling.html" target="_top"> Error and Exception Handling </a> </em>. </span><span class="author"><span class="firstname">David</span> <span class="surname">Abrahams </span>. </span><span class="publisher"><span class="publishername"> Boost - . </span></span></p></div><div class="biblioentry"><a id="idp13649280"></a><p><span class="title"><em> + . </span></span></p></div><div class="biblioentry"><a id="idp13651392"></a><p><span class="title"><em> <a class="link" href="http://www.boost.org/community/exception_safety.html" target="_top"> Exception-Safety in Generic Components </a> </em>. </span><span class="author"><span class="firstname">David</span> <span class="surname">Abrahams</span>. </span><span class="publisher"><span class="publishername"> Boost - . </span></span></p></div><div class="biblioentry"><a id="idp13652992"></a><p><span class="title"><em> + . </span></span></p></div><div class="biblioentry"><a id="idp13655104"></a><p><span class="title"><em> <a class="link" href="www.open-std.org/jtc1/sc22/wg21/docs/papers/1997/N1077.pdf" target="_top"> Standard Library Exception Policy </a> </em>. </span><span class="author"><span class="firstname">Matt</span> <span class="surname">Austern</span>. </span><span class="publisher"><span class="publishername"> WG21 N1077 - . </span></span></p></div><div class="biblioentry"><a id="idp13656704"></a><p><span class="title"><em> + . </span></span></p></div><div class="biblioentry"><a id="idp13658816"></a><p><span class="title"><em> <a class="link" href="http://gcc.gnu.org/ml/gcc-patches/2001-03/msg00661.html" target="_top"> ia64 c++ abi exception handling </a> </em>. </span><span class="author"><span class="firstname">Richard</span> <span class="surname">Henderson</span>. </span><span class="publisher"><span class="publishername"> GNU - . </span></span></p></div><div class="biblioentry"><a id="idp13660400"></a><p><span class="title"><em> + . </span></span></p></div><div class="biblioentry"><a id="idp13662512"></a><p><span class="title"><em> <a class="link" href="http://www.research.att.com/~bs/3rd_safe.pdf" target="_top"> Appendix E: Standard-Library Exception Safety </a> - </em>. </span><span class="author"><span class="firstname">Bjarne</span> <span class="surname">Stroustrup</span>. </span></p></div><div class="biblioentry"><a id="idp13663216"></a><p><span class="citetitle"><em class="citetitle"> + </em>. </span><span class="author"><span class="firstname">Bjarne</span> <span class="surname">Stroustrup</span>. </span></p></div><div class="biblioentry"><a id="idp13665328"></a><p><span class="citetitle"><em class="citetitle"> Exceptional C++ </em>. </span><span class="pagenums"> Exception-Safety Issues and Techniques - . </span><span class="author"><span class="firstname">Herb</span> <span class="surname">Sutter</span>. </span></p></div><div class="biblioentry"><a id="idp13665600"></a><p><span class="title"><em> + . </span><span class="author"><span class="firstname">Herb</span> <span class="surname">Sutter</span>. </span></p></div><div class="biblioentry"><a id="idp13667712"></a><p><span class="title"><em> <a class="link" href="http://gcc.gnu.org/PR25191" target="_top"> GCC Bug 25191: exception_defines.h #defines try/catch </a> diff --git a/libstdc++-v3/doc/html/manual/using_headers.html b/libstdc++-v3/doc/html/manual/using_headers.html index 36ccec10745..66335792fbd 100644 --- a/libstdc++-v3/doc/html/manual/using_headers.html +++ b/libstdc++-v3/doc/html/manual/using_headers.html @@ -18,19 +18,19 @@ the 1998 standard as updated for 2003, and the current 2011 standard. </p><p> C++98/03 include files. These are available in the default compilation mode, i.e. <code class="code">-std=c++98</code> or <code class="code">-std=gnu++98</code>. - </p><div class="table"><a id="idp13077248"></a><p class="title"><strong>Table 3.2. C++ 1998 Library Headers</strong></p><div class="table-contents"><table summary="C++ 1998 Library Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="filename">bitset</code></td><td align="left"><code class="filename">complex</code></td><td align="left"><code class="filename">deque</code></td><td align="left"><code class="filename">exception</code></td></tr><tr><td align="left"><code class="filename">fstream</code></td><td align="left"><code class="filename">functional</code></td><td align="left"><code class="filename">iomanip</code></td><td align="left"><code class="filename">ios</code></td><td align="left"><code class="filename">iosfwd</code></td></tr><tr><td align="left"><code class="filename">iostream</code></td><td align="left"><code class="filename">istream</code></td><td align="left"><code class="filename">iterator</code></td><td align="left"><code class="filename">limits</code></td><td align="left"><code class="filename">list</code></td></tr><tr><td align="left"><code class="filename">locale</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="filename">memory</code></td><td align="left"><code class="filename">new</code></td><td align="left"><code class="filename">numeric</code></td></tr><tr><td align="left"><code class="filename">ostream</code></td><td align="left"><code class="filename">queue</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="filename">sstream</code></td><td align="left"><code class="filename">stack</code></td></tr><tr><td align="left"><code class="filename">stdexcept</code></td><td align="left"><code class="filename">streambuf</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="filename">utility</code></td><td align="left"><code class="filename">typeinfo</code></td></tr><tr><td align="left"><code class="filename">valarray</code></td><td align="left"><code class="filename">vector</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13113728"></a><p class="title"><strong>Table 3.3. C++ 1998 Library Headers for C Library Facilities</strong></p><div class="table-contents"><table summary="C++ 1998 Library Headers for C Library Facilities" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">cassert</code></td><td align="left"><code class="filename">cerrno</code></td><td align="left"><code class="filename">cctype</code></td><td align="left"><code class="filename">cfloat</code></td><td align="left"><code class="filename">ciso646</code></td></tr><tr><td align="left"><code class="filename">climits</code></td><td align="left"><code class="filename">clocale</code></td><td align="left"><code class="filename">cmath</code></td><td align="left"><code class="filename">csetjmp</code></td><td align="left"><code class="filename">csignal</code></td></tr><tr><td align="left"><code class="filename">cstdarg</code></td><td align="left"><code class="filename">cstddef</code></td><td align="left"><code class="filename">cstdio</code></td><td align="left"><code class="filename">cstdlib</code></td><td align="left"><code class="filename">cstring</code></td></tr><tr><td align="left"><code class="filename">ctime</code></td><td align="left"><code class="filename">cwchar</code></td><td align="left"><code class="filename">cwctype</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p> + </p><div class="table"><a id="idp13079360"></a><p class="title"><strong>Table 3.2. C++ 1998 Library Headers</strong></p><div class="table-contents"><table summary="C++ 1998 Library Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="filename">bitset</code></td><td align="left"><code class="filename">complex</code></td><td align="left"><code class="filename">deque</code></td><td align="left"><code class="filename">exception</code></td></tr><tr><td align="left"><code class="filename">fstream</code></td><td align="left"><code class="filename">functional</code></td><td align="left"><code class="filename">iomanip</code></td><td align="left"><code class="filename">ios</code></td><td align="left"><code class="filename">iosfwd</code></td></tr><tr><td align="left"><code class="filename">iostream</code></td><td align="left"><code class="filename">istream</code></td><td align="left"><code class="filename">iterator</code></td><td align="left"><code class="filename">limits</code></td><td align="left"><code class="filename">list</code></td></tr><tr><td align="left"><code class="filename">locale</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="filename">memory</code></td><td align="left"><code class="filename">new</code></td><td align="left"><code class="filename">numeric</code></td></tr><tr><td align="left"><code class="filename">ostream</code></td><td align="left"><code class="filename">queue</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="filename">sstream</code></td><td align="left"><code class="filename">stack</code></td></tr><tr><td align="left"><code class="filename">stdexcept</code></td><td align="left"><code class="filename">streambuf</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="filename">utility</code></td><td align="left"><code class="filename">typeinfo</code></td></tr><tr><td align="left"><code class="filename">valarray</code></td><td align="left"><code class="filename">vector</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13115840"></a><p class="title"><strong>Table 3.3. C++ 1998 Library Headers for C Library Facilities</strong></p><div class="table-contents"><table summary="C++ 1998 Library Headers for C Library Facilities" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">cassert</code></td><td align="left"><code class="filename">cerrno</code></td><td align="left"><code class="filename">cctype</code></td><td align="left"><code class="filename">cfloat</code></td><td align="left"><code class="filename">ciso646</code></td></tr><tr><td align="left"><code class="filename">climits</code></td><td align="left"><code class="filename">clocale</code></td><td align="left"><code class="filename">cmath</code></td><td align="left"><code class="filename">csetjmp</code></td><td align="left"><code class="filename">csignal</code></td></tr><tr><td align="left"><code class="filename">cstdarg</code></td><td align="left"><code class="filename">cstddef</code></td><td align="left"><code class="filename">cstdio</code></td><td align="left"><code class="filename">cstdlib</code></td><td align="left"><code class="filename">cstring</code></td></tr><tr><td align="left"><code class="filename">ctime</code></td><td align="left"><code class="filename">cwchar</code></td><td align="left"><code class="filename">cwctype</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p> C++11 include files. These are only available in C++11 compilation mode, i.e. <code class="literal">-std=c++11</code> or <code class="literal">-std=gnu++11</code>. -</p><p></p><div class="table"><a id="idp13138464"></a><p class="title"><strong>Table 3.4. C++ 2011 Library Headers</strong></p><div class="table-contents"><table summary="C++ 2011 Library Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="filename">array</code></td><td align="left"><code class="filename">bitset</code></td><td align="left"><code class="filename">chrono</code></td><td align="left"><code class="filename">complex</code></td></tr><tr><td align="left"><code class="filename">condition_variable</code></td><td align="left"><code class="filename">deque</code></td><td align="left"><code class="filename">exception</code></td><td align="left"><code class="filename">forward_list</code></td><td align="left"><code class="filename">fstream</code></td></tr><tr><td align="left"><code class="filename">functional</code></td><td align="left"><code class="filename">future</code></td><td align="left"><code class="filename">initalizer_list</code></td><td align="left"><code class="filename">iomanip</code></td><td align="left"><code class="filename">ios</code></td></tr><tr><td align="left"><code class="filename">iosfwd</code></td><td align="left"><code class="filename">iostream</code></td><td align="left"><code class="filename">istream</code></td><td align="left"><code class="filename">iterator</code></td><td align="left"><code class="filename">limits</code></td></tr><tr><td align="left"><code class="filename">list</code></td><td align="left"><code class="filename">locale</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="filename">memory</code></td><td align="left"><code class="filename">mutex</code></td></tr><tr><td align="left"><code class="filename">new</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="filename">ostream</code></td><td align="left"><code class="filename">queue</code></td><td align="left"><code class="filename">random</code></td></tr><tr><td align="left"><code class="filename">ratio</code></td><td align="left"><code class="filename">regex</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="filename">sstream</code></td><td align="left"><code class="filename">stack</code></td></tr><tr><td align="left"><code class="filename">stdexcept</code></td><td align="left"><code class="filename">streambuf</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="filename">system_error</code></td><td align="left"><code class="filename">thread</code></td></tr><tr><td align="left"><code class="filename">tuple</code></td><td align="left"><code class="filename">type_traits</code></td><td align="left"><code class="filename">typeinfo</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="filename">unordered_set</code></td></tr><tr><td align="left"><code class="filename">utility</code></td><td align="left"><code class="filename">valarray</code></td><td align="left"><code class="filename">vector</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13189904"></a><p class="title"><strong>Table 3.5. C++ 2011 Library Headers for C Library Facilities</strong></p><div class="table-contents"><table summary="C++ 2011 Library Headers for C Library Facilities" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">cassert</code></td><td align="left"><code class="filename">ccomplex</code></td><td align="left"><code class="filename">cctype</code></td><td align="left"><code class="filename">cerrno</code></td><td align="left"><code class="filename">cfenv</code></td></tr><tr><td align="left"><code class="filename">cfloat</code></td><td align="left"><code class="filename">cinttypes</code></td><td align="left"><code class="filename">ciso646</code></td><td align="left"><code class="filename">climits</code></td><td align="left"><code class="filename">clocale</code></td></tr><tr><td align="left"><code class="filename">cmath</code></td><td align="left"><code class="filename">csetjmp</code></td><td align="left"><code class="filename">csignal</code></td><td align="left"><code class="filename">cstdarg</code></td><td align="left"><code class="filename">cstdbool</code></td></tr><tr><td align="left"><code class="filename">cstddef</code></td><td align="left"><code class="filename">cstdint</code></td><td align="left"><code class="filename">cstdlib</code></td><td align="left"><code class="filename">cstdio</code></td><td align="left"><code class="filename">cstring</code></td></tr><tr><td align="left"><code class="filename">ctgmath</code></td><td align="left"><code class="filename">ctime</code></td><td align="left"><code class="filename">cuchar</code></td><td align="left"><code class="filename">cwchar</code></td><td align="left"><code class="filename">cwctype</code></td></tr></tbody></table></div></div><br class="table-break" /><p> +</p><p></p><div class="table"><a id="idp13140576"></a><p class="title"><strong>Table 3.4. C++ 2011 Library Headers</strong></p><div class="table-contents"><table summary="C++ 2011 Library Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">algorithm</code></td><td align="left"><code class="filename">array</code></td><td align="left"><code class="filename">bitset</code></td><td align="left"><code class="filename">chrono</code></td><td align="left"><code class="filename">complex</code></td></tr><tr><td align="left"><code class="filename">condition_variable</code></td><td align="left"><code class="filename">deque</code></td><td align="left"><code class="filename">exception</code></td><td align="left"><code class="filename">forward_list</code></td><td align="left"><code class="filename">fstream</code></td></tr><tr><td align="left"><code class="filename">functional</code></td><td align="left"><code class="filename">future</code></td><td align="left"><code class="filename">initalizer_list</code></td><td align="left"><code class="filename">iomanip</code></td><td align="left"><code class="filename">ios</code></td></tr><tr><td align="left"><code class="filename">iosfwd</code></td><td align="left"><code class="filename">iostream</code></td><td align="left"><code class="filename">istream</code></td><td align="left"><code class="filename">iterator</code></td><td align="left"><code class="filename">limits</code></td></tr><tr><td align="left"><code class="filename">list</code></td><td align="left"><code class="filename">locale</code></td><td align="left"><code class="filename">map</code></td><td align="left"><code class="filename">memory</code></td><td align="left"><code class="filename">mutex</code></td></tr><tr><td align="left"><code class="filename">new</code></td><td align="left"><code class="filename">numeric</code></td><td align="left"><code class="filename">ostream</code></td><td align="left"><code class="filename">queue</code></td><td align="left"><code class="filename">random</code></td></tr><tr><td align="left"><code class="filename">ratio</code></td><td align="left"><code class="filename">regex</code></td><td align="left"><code class="filename">set</code></td><td align="left"><code class="filename">sstream</code></td><td align="left"><code class="filename">stack</code></td></tr><tr><td align="left"><code class="filename">stdexcept</code></td><td align="left"><code class="filename">streambuf</code></td><td align="left"><code class="filename">string</code></td><td align="left"><code class="filename">system_error</code></td><td align="left"><code class="filename">thread</code></td></tr><tr><td align="left"><code class="filename">tuple</code></td><td align="left"><code class="filename">type_traits</code></td><td align="left"><code class="filename">typeinfo</code></td><td align="left"><code class="filename">unordered_map</code></td><td align="left"><code class="filename">unordered_set</code></td></tr><tr><td align="left"><code class="filename">utility</code></td><td align="left"><code class="filename">valarray</code></td><td align="left"><code class="filename">vector</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13192016"></a><p class="title"><strong>Table 3.5. C++ 2011 Library Headers for C Library Facilities</strong></p><div class="table-contents"><table summary="C++ 2011 Library Headers for C Library Facilities" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">cassert</code></td><td align="left"><code class="filename">ccomplex</code></td><td align="left"><code class="filename">cctype</code></td><td align="left"><code class="filename">cerrno</code></td><td align="left"><code class="filename">cfenv</code></td></tr><tr><td align="left"><code class="filename">cfloat</code></td><td align="left"><code class="filename">cinttypes</code></td><td align="left"><code class="filename">ciso646</code></td><td align="left"><code class="filename">climits</code></td><td align="left"><code class="filename">clocale</code></td></tr><tr><td align="left"><code class="filename">cmath</code></td><td align="left"><code class="filename">csetjmp</code></td><td align="left"><code class="filename">csignal</code></td><td align="left"><code class="filename">cstdarg</code></td><td align="left"><code class="filename">cstdbool</code></td></tr><tr><td align="left"><code class="filename">cstddef</code></td><td align="left"><code class="filename">cstdint</code></td><td align="left"><code class="filename">cstdlib</code></td><td align="left"><code class="filename">cstdio</code></td><td align="left"><code class="filename">cstring</code></td></tr><tr><td align="left"><code class="filename">ctgmath</code></td><td align="left"><code class="filename">ctime</code></td><td align="left"><code class="filename">cuchar</code></td><td align="left"><code class="filename">cwchar</code></td><td align="left"><code class="filename">cwctype</code></td></tr></tbody></table></div></div><br class="table-break" /><p> In addition, TR1 includes as: -</p><div class="table"><a id="idp13219792"></a><p class="title"><strong>Table 3.6. C++ TR 1 Library Headers</strong></p><div class="table-contents"><table summary="C++ TR 1 Library Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">tr1/array</code></td><td align="left"><code class="filename">tr1/complex</code></td><td align="left"><code class="filename">tr1/memory</code></td><td align="left"><code class="filename">tr1/functional</code></td><td align="left"><code class="filename">tr1/random</code></td></tr><tr><td align="left"><code class="filename">tr1/regex</code></td><td align="left"><code class="filename">tr1/tuple</code></td><td align="left"><code class="filename">tr1/type_traits</code></td><td align="left"><code class="filename">tr1/unordered_map</code></td><td align="left"><code class="filename">tr1/unordered_set</code></td></tr><tr><td align="left"><code class="filename">tr1/utility</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13236720"></a><p class="title"><strong>Table 3.7. C++ TR 1 Library Headers for C Library Facilities</strong></p><div class="table-contents"><table summary="C++ TR 1 Library Headers for C Library Facilities" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">tr1/ccomplex</code></td><td align="left"><code class="filename">tr1/cfenv</code></td><td align="left"><code class="filename">tr1/cfloat</code></td><td align="left"><code class="filename">tr1/cmath</code></td><td align="left"><code class="filename">tr1/cinttypes</code></td></tr><tr><td align="left"><code class="filename">tr1/climits</code></td><td align="left"><code class="filename">tr1/cstdarg</code></td><td align="left"><code class="filename">tr1/cstdbool</code></td><td align="left"><code class="filename">tr1/cstdint</code></td><td align="left"><code class="filename">tr1/cstdio</code></td></tr><tr><td align="left"><code class="filename">tr1/cstdlib</code></td><td align="left"><code class="filename">tr1/ctgmath</code></td><td align="left"><code class="filename">tr1/ctime</code></td><td align="left"><code class="filename">tr1/cwchar</code></td><td align="left"><code class="filename">tr1/cwctype</code></td></tr></tbody></table></div></div><br class="table-break" /><p>Decimal floating-point arithmetic is available if the C++ +</p><div class="table"><a id="idp13221904"></a><p class="title"><strong>Table 3.6. C++ TR 1 Library Headers</strong></p><div class="table-contents"><table summary="C++ TR 1 Library Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">tr1/array</code></td><td align="left"><code class="filename">tr1/complex</code></td><td align="left"><code class="filename">tr1/memory</code></td><td align="left"><code class="filename">tr1/functional</code></td><td align="left"><code class="filename">tr1/random</code></td></tr><tr><td align="left"><code class="filename">tr1/regex</code></td><td align="left"><code class="filename">tr1/tuple</code></td><td align="left"><code class="filename">tr1/type_traits</code></td><td align="left"><code class="filename">tr1/unordered_map</code></td><td align="left"><code class="filename">tr1/unordered_set</code></td></tr><tr><td align="left"><code class="filename">tr1/utility</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13238832"></a><p class="title"><strong>Table 3.7. C++ TR 1 Library Headers for C Library Facilities</strong></p><div class="table-contents"><table summary="C++ TR 1 Library Headers for C Library Facilities" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">tr1/ccomplex</code></td><td align="left"><code class="filename">tr1/cfenv</code></td><td align="left"><code class="filename">tr1/cfloat</code></td><td align="left"><code class="filename">tr1/cmath</code></td><td align="left"><code class="filename">tr1/cinttypes</code></td></tr><tr><td align="left"><code class="filename">tr1/climits</code></td><td align="left"><code class="filename">tr1/cstdarg</code></td><td align="left"><code class="filename">tr1/cstdbool</code></td><td align="left"><code class="filename">tr1/cstdint</code></td><td align="left"><code class="filename">tr1/cstdio</code></td></tr><tr><td align="left"><code class="filename">tr1/cstdlib</code></td><td align="left"><code class="filename">tr1/ctgmath</code></td><td align="left"><code class="filename">tr1/ctime</code></td><td align="left"><code class="filename">tr1/cwchar</code></td><td align="left"><code class="filename">tr1/cwctype</code></td></tr></tbody></table></div></div><br class="table-break" /><p>Decimal floating-point arithmetic is available if the C++ compiler supports scalar decimal floating-point types defined via <code class="code">__attribute__((mode(SD|DD|LD)))</code>. -</p><div class="table"><a id="idp13257792"></a><p class="title"><strong>Table 3.8. C++ TR 24733 Decimal Floating-Point Header</strong></p><div class="table-contents"><table summary="C++ TR 24733 Decimal Floating-Point Header" border="1"><colgroup><col align="left" class="c1" /></colgroup><tbody><tr><td align="left"><code class="filename">decimal/decimal</code></td></tr></tbody></table></div></div><br class="table-break" /><p> +</p><div class="table"><a id="idp13259904"></a><p class="title"><strong>Table 3.8. C++ TR 24733 Decimal Floating-Point Header</strong></p><div class="table-contents"><table summary="C++ TR 24733 Decimal Floating-Point Header" border="1"><colgroup><col align="left" class="c1" /></colgroup><tbody><tr><td align="left"><code class="filename">decimal/decimal</code></td></tr></tbody></table></div></div><br class="table-break" /><p> Also included are files for the C++ ABI interface: -</p><div class="table"><a id="idp13263312"></a><p class="title"><strong>Table 3.9. C++ ABI Headers</strong></p><div class="table-contents"><table summary="C++ ABI Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><tbody><tr><td align="left"><code class="filename">cxxabi.h</code></td><td align="left"><code class="filename">cxxabi_forced.h</code></td></tr></tbody></table></div></div><br class="table-break" /><p> +</p><div class="table"><a id="idp13265424"></a><p class="title"><strong>Table 3.9. C++ ABI Headers</strong></p><div class="table-contents"><table summary="C++ ABI Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><tbody><tr><td align="left"><code class="filename">cxxabi.h</code></td><td align="left"><code class="filename">cxxabi_forced.h</code></td></tr></tbody></table></div></div><br class="table-break" /><p> And a large variety of extensions. -</p><div class="table"><a id="idp13269712"></a><p class="title"><strong>Table 3.10. Extension Headers</strong></p><div class="table-contents"><table summary="Extension Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">ext/algorithm</code></td><td align="left"><code class="filename">ext/atomicity.h</code></td><td align="left"><code class="filename">ext/array_allocator.h</code></td><td align="left"><code class="filename">ext/bitmap_allocator.h</code></td><td align="left"><code class="filename">ext/cast.h</code></td></tr><tr><td align="left"><code class="filename">ext/codecvt_specializations.h</code></td><td align="left"><code class="filename">ext/concurrence.h</code></td><td align="left"><code class="filename">ext/debug_allocator.h</code></td><td align="left"><code class="filename">ext/enc_filebuf.h</code></td><td align="left"><code class="filename">ext/extptr_allocator.h</code></td></tr><tr><td align="left"><code class="filename">ext/functional</code></td><td align="left"><code class="filename">ext/iterator</code></td><td align="left"><code class="filename">ext/malloc_allocator.h</code></td><td align="left"><code class="filename">ext/memory</code></td><td align="left"><code class="filename">ext/mt_allocator.h</code></td></tr><tr><td align="left"><code class="filename">ext/new_allocator.h</code></td><td align="left"><code class="filename">ext/numeric</code></td><td align="left"><code class="filename">ext/numeric_traits.h</code></td><td align="left"><code class="filename">ext/pb_ds/assoc_container.h</code></td><td align="left"><code class="filename">ext/pb_ds/priority_queue.h</code></td></tr><tr><td align="left"><code class="filename">ext/pod_char_traits.h</code></td><td align="left"><code class="filename">ext/pool_allocator.h</code></td><td align="left"><code class="filename">ext/rb_tree</code></td><td align="left"><code class="filename">ext/rope</code></td><td align="left"><code class="filename">ext/slist</code></td></tr><tr><td align="left"><code class="filename">ext/stdio_filebuf.h</code></td><td align="left"><code class="filename">ext/stdio_sync_filebuf.h</code></td><td align="left"><code class="filename">ext/throw_allocator.h</code></td><td align="left"><code class="filename">ext/typelist.h</code></td><td align="left"><code class="filename">ext/type_traits.h</code></td></tr><tr><td align="left"><code class="filename">ext/vstring.h</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13305440"></a><p class="title"><strong>Table 3.11. Extension Debug Headers</strong></p><div class="table-contents"><table summary="Extension Debug Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">debug/bitset</code></td><td align="left"><code class="filename">debug/deque</code></td><td align="left"><code class="filename">debug/list</code></td><td align="left"><code class="filename">debug/map</code></td><td align="left"><code class="filename">debug/set</code></td></tr><tr><td align="left"><code class="filename">debug/string</code></td><td align="left"><code class="filename">debug/unordered_map</code></td><td align="left"><code class="filename">debug/unordered_set</code></td><td align="left"><code class="filename">debug/vector</code></td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13320208"></a><p class="title"><strong>Table 3.12. Extension Profile Headers</strong></p><div class="table-contents"><table summary="Extension Profile Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><tbody><tr><td align="left"><code class="filename">profile/bitset</code></td><td align="left"><code class="filename">profile/deque</code></td><td align="left"><code class="filename">profile/list</code></td><td align="left"><code class="filename">profile/map</code></td></tr><tr><td align="left"><code class="filename">profile/set</code></td><td align="left"><code class="filename">profile/unordered_map</code></td><td align="left"><code class="filename">profile/unordered_set</code></td><td align="left"><code class="filename">profile/vector</code></td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13333584"></a><p class="title"><strong>Table 3.13. Extension Parallel Headers</strong></p><div class="table-contents"><table summary="Extension Parallel Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><tbody><tr><td align="left"><code class="filename">parallel/algorithm</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr></tbody></table></div></div><br class="table-break" /></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="manual.intro.using.headers.mixing"></a>Mixing Headers</h3></div></div></div><p> A few simple rules. +</p><div class="table"><a id="idp13271824"></a><p class="title"><strong>Table 3.10. Extension Headers</strong></p><div class="table-contents"><table summary="Extension Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">ext/algorithm</code></td><td align="left"><code class="filename">ext/atomicity.h</code></td><td align="left"><code class="filename">ext/array_allocator.h</code></td><td align="left"><code class="filename">ext/bitmap_allocator.h</code></td><td align="left"><code class="filename">ext/cast.h</code></td></tr><tr><td align="left"><code class="filename">ext/codecvt_specializations.h</code></td><td align="left"><code class="filename">ext/concurrence.h</code></td><td align="left"><code class="filename">ext/debug_allocator.h</code></td><td align="left"><code class="filename">ext/enc_filebuf.h</code></td><td align="left"><code class="filename">ext/extptr_allocator.h</code></td></tr><tr><td align="left"><code class="filename">ext/functional</code></td><td align="left"><code class="filename">ext/iterator</code></td><td align="left"><code class="filename">ext/malloc_allocator.h</code></td><td align="left"><code class="filename">ext/memory</code></td><td align="left"><code class="filename">ext/mt_allocator.h</code></td></tr><tr><td align="left"><code class="filename">ext/new_allocator.h</code></td><td align="left"><code class="filename">ext/numeric</code></td><td align="left"><code class="filename">ext/numeric_traits.h</code></td><td align="left"><code class="filename">ext/pb_ds/assoc_container.h</code></td><td align="left"><code class="filename">ext/pb_ds/priority_queue.h</code></td></tr><tr><td align="left"><code class="filename">ext/pod_char_traits.h</code></td><td align="left"><code class="filename">ext/pool_allocator.h</code></td><td align="left"><code class="filename">ext/rb_tree</code></td><td align="left"><code class="filename">ext/rope</code></td><td align="left"><code class="filename">ext/slist</code></td></tr><tr><td align="left"><code class="filename">ext/stdio_filebuf.h</code></td><td align="left"><code class="filename">ext/stdio_sync_filebuf.h</code></td><td align="left"><code class="filename">ext/throw_allocator.h</code></td><td align="left"><code class="filename">ext/typelist.h</code></td><td align="left"><code class="filename">ext/type_traits.h</code></td></tr><tr><td align="left"><code class="filename">ext/vstring.h</code></td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13307552"></a><p class="title"><strong>Table 3.11. Extension Debug Headers</strong></p><div class="table-contents"><table summary="Extension Debug Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /><col align="left" class="c5" /></colgroup><tbody><tr><td align="left"><code class="filename">debug/bitset</code></td><td align="left"><code class="filename">debug/deque</code></td><td align="left"><code class="filename">debug/list</code></td><td align="left"><code class="filename">debug/map</code></td><td align="left"><code class="filename">debug/set</code></td></tr><tr><td align="left"><code class="filename">debug/string</code></td><td align="left"><code class="filename">debug/unordered_map</code></td><td align="left"><code class="filename">debug/unordered_set</code></td><td align="left"><code class="filename">debug/vector</code></td><td class="auto-generated"> </td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13322320"></a><p class="title"><strong>Table 3.12. Extension Profile Headers</strong></p><div class="table-contents"><table summary="Extension Profile Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><tbody><tr><td align="left"><code class="filename">profile/bitset</code></td><td align="left"><code class="filename">profile/deque</code></td><td align="left"><code class="filename">profile/list</code></td><td align="left"><code class="filename">profile/map</code></td></tr><tr><td align="left"><code class="filename">profile/set</code></td><td align="left"><code class="filename">profile/unordered_map</code></td><td align="left"><code class="filename">profile/unordered_set</code></td><td align="left"><code class="filename">profile/vector</code></td></tr></tbody></table></div></div><br class="table-break" /><p></p><div class="table"><a id="idp13335696"></a><p class="title"><strong>Table 3.13. Extension Parallel Headers</strong></p><div class="table-contents"><table summary="Extension Parallel Headers" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /></colgroup><tbody><tr><td align="left"><code class="filename">parallel/algorithm</code></td><td align="left"><code class="filename">parallel/numeric</code></td></tr></tbody></table></div></div><br class="table-break" /></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="manual.intro.using.headers.mixing"></a>Mixing Headers</h3></div></div></div><p> A few simple rules. </p><p>First, mixing different dialects of the standard headers is not possible. It's an all-or-nothing affair. Thus, code like </p><pre class="programlisting"> diff --git a/libstdc++-v3/doc/html/manual/utilities.html b/libstdc++-v3/doc/html/manual/utilities.html index ac524530360..fefc295bf75 100644 --- a/libstdc++-v3/doc/html/manual/utilities.html +++ b/libstdc++-v3/doc/html/manual/utilities.html @@ -6,8 +6,8 @@ Standard Contents </th><td width="20%" align="right"> <a accesskey="n" href="pairs.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="std.util"></a>Chapter 6. Utilities - <a id="idp13860304" class="indexterm"></a> -</h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="utilities.html#std.util.functors">Functors</a></span></dt><dt><span class="section"><a href="pairs.html">Pairs</a></span></dt><dt><span class="section"><a href="memory.html">Memory</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#std.util.memory.allocator">Allocators</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#allocator.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#allocator.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#allocator.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp13918736">Interface Design</a></span></dt><dt><span class="section"><a href="memory.html#idp13922288">Selecting Default Allocation Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp13935584">Disabling Memory Caching</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#allocator.using">Using a Specific Allocator</a></span></dt><dt><span class="section"><a href="memory.html#allocator.custom">Custom Allocators</a></span></dt><dt><span class="section"><a href="memory.html#allocator.ext">Extension Allocators</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.auto_ptr">auto_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#auto_ptr.limitations">Limitations</a></span></dt><dt><span class="section"><a href="memory.html#auto_ptr.using">Use in Containers</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.shared_ptr">shared_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#shared_ptr.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15511664">Class Hierarchy</a></span></dt><dt><span class="section"><a href="memory.html#idp15534176">Thread Safety</a></span></dt><dt><span class="section"><a href="memory.html#idp15541472">Selecting Lock Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp15556096">Related functions and classes</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.using">Use</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15572448">Examples</a></span></dt><dt><span class="section"><a href="memory.html#idp15576032">Unresolved Issues</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.ack">Acknowledgments</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="traits.html">Traits</a></span></dt></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.util.functors"></a>Functors</h2></div></div></div><p>If you don't know what functors are, you're not alone. Many people + <a id="idp13862416" class="indexterm"></a> +</h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl><dt><span class="section"><a href="utilities.html#std.util.functors">Functors</a></span></dt><dt><span class="section"><a href="pairs.html">Pairs</a></span></dt><dt><span class="section"><a href="memory.html">Memory</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#std.util.memory.allocator">Allocators</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#allocator.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#allocator.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#allocator.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp13920976">Interface Design</a></span></dt><dt><span class="section"><a href="memory.html#idp13924528">Selecting Default Allocation Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp13937824">Disabling Memory Caching</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#allocator.using">Using a Specific Allocator</a></span></dt><dt><span class="section"><a href="memory.html#allocator.custom">Custom Allocators</a></span></dt><dt><span class="section"><a href="memory.html#allocator.ext">Extension Allocators</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.auto_ptr">auto_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#auto_ptr.limitations">Limitations</a></span></dt><dt><span class="section"><a href="memory.html#auto_ptr.using">Use in Containers</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#std.util.memory.shared_ptr">shared_ptr</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#shared_ptr.req">Requirements</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.design_issues">Design Issues</a></span></dt><dt><span class="section"><a href="memory.html#shared_ptr.impl">Implementation</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15512272">Class Hierarchy</a></span></dt><dt><span class="section"><a href="memory.html#idp15534784">Thread Safety</a></span></dt><dt><span class="section"><a href="memory.html#idp15542080">Selecting Lock Policy</a></span></dt><dt><span class="section"><a href="memory.html#idp15556704">Related functions and classes</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.using">Use</a></span></dt><dd><dl><dt><span class="section"><a href="memory.html#idp15573056">Examples</a></span></dt><dt><span class="section"><a href="memory.html#idp15576640">Unresolved Issues</a></span></dt></dl></dd><dt><span class="section"><a href="memory.html#shared_ptr.ack">Acknowledgments</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="traits.html">Traits</a></span></dt></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="std.util.functors"></a>Functors</h2></div></div></div><p>If you don't know what functors are, you're not alone. Many people get slightly the wrong idea. In the interest of not reinventing the wheel, we will refer you to the introduction to the functor concept written by SGI as part of their STL, in 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_tree.h b/libstdc++-v3/include/bits/stl_tree.h index 59883fca834..cb5a8eff800 100644 --- a/libstdc++-v3/include/bits/stl_tree.h +++ b/libstdc++-v3/include/bits/stl_tree.h @@ -62,6 +62,9 @@ #include <bits/allocator.h> #include <bits/stl_function.h> #include <bits/cpp_type_traits.h> +#if __cplusplus >= 201103L +#include <bits/alloc_traits.h> +#endif namespace std _GLIBCXX_VISIBILITY(default) { @@ -400,8 +403,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Link_type __tmp = _M_get_node(); __try { - _M_get_Node_allocator().construct(__tmp, - std::forward<_Args>(__args)...); + allocator_traits<_Node_allocator>:: + construct(_M_get_Node_allocator(), __tmp, + std::forward<_Args>(__args)...); } __catch(...) { diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h index d880ba77905..69c6e278c06 100644 --- a/libstdc++-v3/include/bits/stl_vector.h +++ b/libstdc++-v3/include/bits/stl_vector.h @@ -1184,7 +1184,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/ext/debug_allocator.h b/libstdc++-v3/include/ext/debug_allocator.h index 8190d2a89a7..9bb73f06161 100644 --- a/libstdc++-v3/include/ext/debug_allocator.h +++ b/libstdc++-v3/include/ext/debug_allocator.h @@ -43,6 +43,8 @@ #define _DEBUG_ALLOCATOR_H 1 #include <stdexcept> +#include <bits/functexcept.h> +#include <ext/alloc_traits.h> namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { @@ -51,24 +53,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using std::size_t; /** - * @brief A meta-allocator with debugging bits, as per [20.4]. + * @brief A meta-allocator with debugging bits. * @ingroup allocators * - * This is precisely the allocator defined in the C++ Standard. - * - all allocation calls operator new - * - all deallocation calls operator delete + * This is precisely the allocator defined in the C++03 Standard. */ template<typename _Alloc> class debug_allocator { + template<typename> friend class debug_allocator; + + typedef __alloc_traits<_Alloc> _Traits; + public: - typedef typename _Alloc::size_type size_type; - typedef typename _Alloc::difference_type difference_type; - typedef typename _Alloc::pointer pointer; - typedef typename _Alloc::const_pointer const_pointer; - typedef typename _Alloc::reference reference; - typedef typename _Alloc::const_reference const_reference; - typedef typename _Alloc::value_type value_type; + typedef typename _Traits::size_type size_type; + typedef typename _Traits::difference_type difference_type; + typedef typename _Traits::pointer pointer; + typedef typename _Traits::const_pointer const_pointer; + typedef typename _Traits::reference reference; + typedef typename _Traits::const_reference const_reference; + typedef typename _Traits::value_type value_type; + + template<typename _Up> + class rebind + { + typedef typename _Traits::template rebind<_Up>::other __other; + + public: + typedef debug_allocator<__other> other; + }; private: // _M_extra is the number of objects that correspond to the @@ -77,13 +90,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Alloc _M_allocator; - public: - debug_allocator() + template<typename _Alloc2, + typename = typename _Alloc2::template rebind<value_type>::other> + struct __convertible + { }; + + template<typename _Alloc2> + struct __convertible<_Alloc2, _Alloc> + { + typedef void* __type; + }; + + size_type _S_extra() { const size_t __obj_size = sizeof(value_type); - _M_extra = (sizeof(size_type) + __obj_size - 1) / __obj_size; + return (sizeof(size_type) + __obj_size - 1) / __obj_size; } - + + public: + debug_allocator() : _M_extra(_S_extra()) { } + + template<typename _Alloc2> + debug_allocator(const debug_allocator<_Alloc2>& __a2, + typename __convertible<_Alloc2>::__type = 0) + : _M_allocator(__a2._M_allocator), _M_extra(_S_extra()) { } + + debug_allocator(const _Alloc& __a) + : _M_allocator(__a), _M_extra(_S_extra()) { } + pointer allocate(size_type __n) { @@ -105,21 +139,52 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void deallocate(pointer __p, size_type __n) { + using std::__throw_runtime_error; if (__p) { pointer __real_p = __p - _M_extra; if (*reinterpret_cast<size_type*>(__real_p) != __n) - { - throw std::runtime_error("debug_allocator::deallocate" - " wrong size"); - } + __throw_runtime_error("debug_allocator::deallocate wrong size"); _M_allocator.deallocate(__real_p, __n + _M_extra); } else - throw std::runtime_error("debug_allocator::deallocate null pointer"); + __throw_runtime_error("debug_allocator::deallocate null pointer"); } + + void + construct(pointer __p, const value_type& __val) + { _Traits::construct(_M_allocator, __p, __val); } + +#if __cplusplus >= 201103L + template<typename _Tp, typename... _Args> + void + construct(_Tp* __p, _Args&&... __args) + { + _Traits::construct(_M_allocator, __p, + std::forward<_Args>(__args)...); + } +#endif + + template<typename _Tp> + void + destroy(_Tp* __p) + { _Traits::destroy(_M_allocator, __p); } + + size_type + max_size() const throw() + { return _Traits::max_size(_M_allocator) - _M_extra; } + + friend bool + operator==(const debug_allocator& __lhs, const debug_allocator& __rhs) + { return __lhs._M_allocator == __rhs._M_allocator; } }; + template<typename _Alloc> + inline bool + operator!=(const debug_allocator<_Alloc>& __lhs, + const debug_allocator<_Alloc>& __rhs) + { return !(__lhs == __rhs); } + _GLIBCXX_END_NAMESPACE_VERSION } // namespace diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono index e4b92a59405..711131920f0 100644 --- a/libstdc++-v3/include/std/chrono +++ b/libstdc++-v3/include/std/chrono @@ -225,7 +225,7 @@ _GLIBCXX_END_NAMESPACE_VERSION { return numeric_limits<_Rep>::lowest(); } }; - template<typename T> + template<typename _Tp> struct __is_ratio : std::false_type { }; diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future index 6cccd3d3f2a..30100fe05e4 100644 --- a/libstdc++-v3/include/std/future +++ b/libstdc++-v3/include/std/future @@ -214,6 +214,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool _M_initialized; public: + typedef _Res result_type; + _Result() noexcept : _M_initialized() { } ~_Result() @@ -281,17 +283,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename __traits::allocator_type __a2(__a); __result_type* __p = __traits::allocate(__a2, 1); __try - { - __traits::construct(__a2, __p, __a); - } + { + __traits::construct(__a2, __p, __a); + } __catch(...) - { - __traits::deallocate(__a2, __p, 1); - __throw_exception_again; - } + { + __traits::deallocate(__a2, __p, 1); + __throw_exception_again; + } return _Ptr<__result_type>(__p); } + template<typename _Res, typename _Tp> + static _Ptr<_Result<_Res>> + _S_allocate_result(const std::allocator<_Tp>& __a) + { + return _Ptr<_Result<_Res>>(new _Result<_Res>); + } /// Base class for state between a promise and one or more /// associated futures. @@ -482,6 +490,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION class _Async_state_impl; template<typename _Signature> + class _Task_state_base; + + template<typename _Fn, typename _Alloc, typename _Signature> class _Task_state; template<typename _BoundFn> @@ -492,24 +503,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static std::shared_ptr<_State_base> _S_make_async_state(_BoundFn&& __fn); - template<typename _Res_ptr, typename _Res> + template<typename _Res_ptr, + typename _Res = typename _Res_ptr::element_type::result_type> struct _Task_setter; template<typename _Res_ptr, typename _BoundFn> - class _Task_setter_helper - { - typedef typename remove_reference<_BoundFn>::type::result_type __res; - public: - typedef _Task_setter<_Res_ptr, __res> __type; - }; - - template<typename _Res_ptr, typename _BoundFn> - static typename _Task_setter_helper<_Res_ptr, _BoundFn>::__type + static _Task_setter<_Res_ptr> _S_task_setter(_Res_ptr& __ptr, _BoundFn&& __call) { - typedef _Task_setter_helper<_Res_ptr, _BoundFn> __helper_type; - typedef typename __helper_type::__type _Setter; - return _Setter{ __ptr, std::ref(__call) }; + return _Task_setter<_Res_ptr>{ __ptr, std::ref(__call) }; } }; @@ -517,6 +519,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Res> struct __future_base::_Result<_Res&> : __future_base::_Result_base { + typedef _Res& result_type; + _Result() noexcept : _M_value_ptr() { } void _M_set(_Res& __res) noexcept { _M_value_ptr = &__res; } @@ -533,6 +537,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct __future_base::_Result<void> : __future_base::_Result_base { + typedef void result_type; + private: void _M_destroy() { delete this; } }; @@ -1197,7 +1203,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { _Ptr_type operator()() { - __try + __try { _M_result->_M_set(_M_fn()); } @@ -1205,7 +1211,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { _M_result->_M_error = current_exception(); } - return std::move(_M_result); + return std::move(_M_result); } _Ptr_type& _M_result; std::function<_Res()> _M_fn; @@ -1216,7 +1222,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { _Ptr_type operator()() { - __try + __try { _M_fn(); } @@ -1231,49 +1237,85 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; template<typename _Res, typename... _Args> - struct __future_base::_Task_state<_Res(_Args...)> final + struct __future_base::_Task_state_base<_Res(_Args...)> : __future_base::_State_base { typedef _Res _Res_type; - _Task_state(std::function<_Res(_Args...)> __task) - : _M_result(new _Result<_Res>()), _M_task(std::move(__task)) - { } + template<typename _Alloc> + _Task_state_base(const _Alloc& __a) + : _M_result(_S_allocate_result<_Res>(__a)) + { } - template<typename _Func, typename _Alloc> - _Task_state(_Func&& __task, const _Alloc& __a) - : _M_result(_S_allocate_result<_Res>(__a)), - _M_task(allocator_arg, __a, std::move(__task)) - { } + virtual void + _M_run(_Args... __args) = 0; - void + virtual shared_ptr<_Task_state_base> + _M_reset() = 0; + + typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; + _Ptr_type _M_result; + }; + + template<typename _Fn, typename _Alloc, typename _Res, typename... _Args> + struct __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)> final + : __future_base::_Task_state_base<_Res(_Args...)> + { + _Task_state(_Fn&& __fn, const _Alloc& __a) + : _Task_state_base<_Res(_Args...)>(__a), _M_impl(std::move(__fn), __a) + { } + + private: + virtual void _M_run(_Args... __args) { - // bound arguments decay so wrap lvalue references - auto __boundfn = std::__bind_simple(std::ref(_M_task), + // bound arguments decay so wrap lvalue references + auto __boundfn = std::__bind_simple(std::ref(_M_impl._M_fn), _S_maybe_wrap_ref(std::forward<_Args>(__args))...); - auto __setter = _S_task_setter(_M_result, std::move(__boundfn)); - _M_set_result(std::move(__setter)); + auto __setter = _S_task_setter(this->_M_result, std::move(__boundfn)); + this->_M_set_result(std::move(__setter)); } - typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; - _Ptr_type _M_result; - std::function<_Res(_Args...)> _M_task; + virtual shared_ptr<_Task_state_base<_Res(_Args...)>> + _M_reset(); template<typename _Tp> - static reference_wrapper<_Tp> - _S_maybe_wrap_ref(_Tp& __t) - { return std::ref(__t); } + static reference_wrapper<_Tp> + _S_maybe_wrap_ref(_Tp& __t) + { return std::ref(__t); } template<typename _Tp> - static typename enable_if<!is_lvalue_reference<_Tp>::value, - _Tp>::type&& - _S_maybe_wrap_ref(_Tp&& __t) - { return std::forward<_Tp>(__t); } + static + typename enable_if<!is_lvalue_reference<_Tp>::value, _Tp>::type&& + _S_maybe_wrap_ref(_Tp&& __t) + { return std::forward<_Tp>(__t); } + + struct _Impl : _Alloc + { + _Impl(_Fn&& __fn, const _Alloc& __a) + : _Alloc(__a), _M_fn(std::move(__fn)) { } + _Fn _M_fn; + } _M_impl; }; + template<typename _Signature, typename _Fn, typename _Alloc> + static shared_ptr<__future_base::_Task_state_base<_Signature>> + __create_task_state(_Fn&& __fn, const _Alloc& __a) + { + typedef __future_base::_Task_state<_Fn, _Alloc, _Signature> _State; + return std::allocate_shared<_State>(__a, std::move(__fn), __a); + } + + template<typename _Fn, typename _Alloc, typename _Res, typename... _Args> + shared_ptr<__future_base::_Task_state_base<_Res(_Args...)>> + __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)>::_M_reset() + { + return __create_task_state<_Res(_Args...)>(std::move(_M_impl._M_fn), + static_cast<_Alloc&>(_M_impl)); + } + template<typename _Task, typename _Fn, bool - = is_same<_Task, typename decay<_Fn>::type>::value> + = is_same<_Task, typename decay<_Fn>::type>::value> struct __constrain_pkgdtask { typedef void __type; }; @@ -1285,7 +1327,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Res, typename... _ArgTypes> class packaged_task<_Res(_ArgTypes...)> { - typedef __future_base::_Task_state<_Res(_ArgTypes...)> _State_type; + typedef __future_base::_Task_state_base<_Res(_ArgTypes...)> _State_type; shared_ptr<_State_type> _M_state; public: @@ -1295,31 +1337,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2095. missing constructors needed for uses-allocator construction template<typename _Allocator> - explicit - packaged_task(allocator_arg_t, const _Allocator& __a) noexcept - { } + packaged_task(allocator_arg_t, const _Allocator& __a) noexcept + { } template<typename _Fn, typename = typename - __constrain_pkgdtask<packaged_task, _Fn>::__type> - explicit - packaged_task(_Fn&& __fn) - : _M_state(std::make_shared<_State_type>(std::forward<_Fn>(__fn))) - { } + __constrain_pkgdtask<packaged_task, _Fn>::__type> + explicit + packaged_task(_Fn&& __fn) + : packaged_task(allocator_arg, std::allocator<int>(), std::move(__fn)) + { } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2097. packaged_task constructors should be constrained - template<typename _Fn, typename _Allocator, typename = typename - __constrain_pkgdtask<packaged_task, _Fn>::__type> - explicit - packaged_task(allocator_arg_t, const _Allocator& __a, _Fn&& __fn) - : _M_state(std::allocate_shared<_State_type>(__a, - std::forward<_Fn>(__fn))) - { } + template<typename _Fn, typename _Alloc, typename = typename + __constrain_pkgdtask<packaged_task, _Fn>::__type> + explicit + packaged_task(allocator_arg_t, const _Alloc& __a, _Fn&& __fn) + : _M_state(__create_task_state<_Res(_ArgTypes...)>( + std::forward<_Fn>(__fn), __a)) + { } ~packaged_task() { if (static_cast<bool>(_M_state) && !_M_state.unique()) - _M_state->_M_break_promise(std::move(_M_state->_M_result)); + _M_state->_M_break_promise(std::move(_M_state->_M_result)); } // No copy @@ -1327,24 +1368,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION packaged_task& operator=(const packaged_task&) = delete; template<typename _Allocator> - explicit - packaged_task(allocator_arg_t, const _Allocator&, - const packaged_task&) = delete; + packaged_task(allocator_arg_t, const _Allocator&, + const packaged_task&) = delete; // Move support packaged_task(packaged_task&& __other) noexcept { this->swap(__other); } template<typename _Allocator> - explicit - packaged_task(allocator_arg_t, const _Allocator&, - packaged_task&& __other) noexcept - { this->swap(__other); } + packaged_task(allocator_arg_t, const _Allocator&, + packaged_task&& __other) noexcept + { this->swap(__other); } packaged_task& operator=(packaged_task&& __other) noexcept { - packaged_task(std::move(__other)).swap(*this); - return *this; + packaged_task(std::move(__other)).swap(*this); + return *this; } void @@ -1364,15 +1403,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void operator()(_ArgTypes... __args) { - __future_base::_State_base::_S_check(_M_state); - _M_state->_M_run(std::forward<_ArgTypes>(__args)...); + __future_base::_State_base::_S_check(_M_state); + _M_state->_M_run(std::forward<_ArgTypes>(__args)...); } void reset() { - __future_base::_State_base::_S_check(_M_state); - packaged_task(std::move(_M_state->_M_task)).swap(*this); + __future_base::_State_base::_S_check(_M_state); + packaged_task __tmp; + __tmp._M_state = _M_state; + _M_state = _M_state->_M_reset(); } }; 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/include/std/type_traits b/libstdc++-v3/include/std/type_traits index 62d59128f9f..334b8d0ab38 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -444,7 +444,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// is_fundamental template<typename _Tp> struct is_fundamental - : public __or_<is_arithmetic<_Tp>, is_void<_Tp>>::type + : public __or_<is_arithmetic<_Tp>, is_void<_Tp>, __is_nullptr_t<_Tp>>::type { }; /// is_object diff --git a/libstdc++-v3/libsupc++/eh_catch.cc b/libstdc++-v3/libsupc++/eh_catch.cc index 779f5a31058..43e875a95d2 100644 --- a/libstdc++-v3/libsupc++/eh_catch.cc +++ b/libstdc++-v3/libsupc++/eh_catch.cc @@ -80,6 +80,9 @@ __cxxabiv1::__cxa_begin_catch (void *exc_obj_in) _GLIBCXX_NOTHROW } objectp = __gxx_caught_object(exceptionObject); + + PROBE2 (catch, objectp, header->exceptionType); + #ifdef __ARM_EABI_UNWINDER__ _Unwind_Complete(exceptionObject); #endif diff --git a/libstdc++-v3/libsupc++/eh_throw.cc b/libstdc++-v3/libsupc++/eh_throw.cc index 297aa04df6e..a79a025af19 100644 --- a/libstdc++-v3/libsupc++/eh_throw.cc +++ b/libstdc++-v3/libsupc++/eh_throw.cc @@ -60,6 +60,8 @@ extern "C" void __cxxabiv1::__cxa_throw (void *obj, std::type_info *tinfo, void (_GLIBCXX_CDTOR_CALLABI *dest) (void *)) { + PROBE2 (throw, obj, tinfo); + // Definitely a primary. __cxa_refcounted_exception *header = __get_refcounted_exception_header_from_obj (obj); @@ -97,7 +99,12 @@ __cxxabiv1::__cxa_rethrow () if (!__is_gxx_exception_class(header->unwindHeader.exception_class)) globals->caughtExceptions = 0; else - header->handlerCount = -header->handlerCount; + { + header->handlerCount = -header->handlerCount; + // Only notify probe for C++ exceptions. + PROBE2 (rethrow, __get_object_from_ambiguous_exception(header), + header->exceptionType); + } #ifdef _GLIBCXX_SJLJ_EXCEPTIONS _Unwind_SjLj_Resume_or_Rethrow (&header->unwindHeader); 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/libsupc++/unwind-cxx.h b/libstdc++-v3/libsupc++/unwind-cxx.h index e2b945d9969..ed4eea56655 100644 --- a/libstdc++-v3/libsupc++/unwind-cxx.h +++ b/libstdc++-v3/libsupc++/unwind-cxx.h @@ -37,6 +37,19 @@ #include <bits/atomic_word.h> #include <cxxabi.h> +#ifdef _GLIBCXX_HAVE_SYS_SDT_H +#include <sys/sdt.h> +/* We only want to use stap probes starting with v3. Earlier versions + added too much startup cost. */ +#if defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3 +#define PROBE2(name, arg1, arg2) STAP_PROBE2 (libstdcxx, name, arg1, arg2) +#endif +#endif + +#ifndef PROBE2 +#define PROBE2(name, arg1, arg2) +#endif + #pragma GCC visibility push(default) namespace __cxxabiv1 diff --git a/libstdc++-v3/testsuite/18_support/50594.cc b/libstdc++-v3/testsuite/18_support/50594.cc index c78cb387c55..715fe64dd02 100644 --- a/libstdc++-v3/testsuite/18_support/50594.cc +++ b/libstdc++-v3/testsuite/18_support/50594.cc @@ -1,4 +1,5 @@ // { dg-options "-fwhole-program" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // Copyright (C) 2011-2013 Free Software Foundation, Inc. // diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_category/operators/equal.cc b/libstdc++-v3/testsuite/19_diagnostics/error_category/operators/equal.cc index dc66122ef0c..23eeb0288a6 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_category/operators/equal.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_category/operators/equal.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libgcc" { target *-*-mingw* } } // 2007-08-22 Benjamin Kosnik <bkoz@redhat.com> // Copyright (C) 2007-2013 Free Software Foundation, Inc. diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_code/cons/1.cc b/libstdc++-v3/testsuite/19_diagnostics/error_code/cons/1.cc index 687fbd658a0..31ac0e0640b 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_code/cons/1.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_code/cons/1.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // 2007-08-22 Benjamin Kosnik <bkoz@redhat.com> // Copyright (C) 2007-2013 Free Software Foundation, Inc. diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/bool.cc b/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/bool.cc index 3266be07c78..6bbc99035c7 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/bool.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/bool.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // 2007-08-22 Benjamin Kosnik <bkoz@redhat.com> // Copyright (C) 2007-2013 Free Software Foundation, Inc. diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/equal.cc b/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/equal.cc index b886046813c..4c03ba0e435 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/equal.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/equal.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // 2007-08-22 Benjamin Kosnik <bkoz@redhat.com> // Copyright (C) 2007-2013 Free Software Foundation, Inc. diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/not_equal.cc b/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/not_equal.cc index 99a58c30cf4..195e416f5f3 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/not_equal.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_code/operators/not_equal.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // 2007-08-22 Benjamin Kosnik <bkoz@redhat.com> // Copyright (C) 2007-2013 Free Software Foundation, Inc. diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_condition/cons/1.cc b/libstdc++-v3/testsuite/19_diagnostics/error_condition/cons/1.cc index 55353dca289..f083294955e 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_condition/cons/1.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_condition/cons/1.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // Copyright (C) 2008-2013 Free Software Foundation, Inc. // diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/bool.cc b/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/bool.cc index 90ff4a423e4..01d6f8d3d77 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/bool.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/bool.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // Copyright (C) 2008-2013 Free Software Foundation, Inc. // diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/equal.cc b/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/equal.cc index c80a772454e..e5a622735ca 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/equal.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/equal.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // Copyright (C) 2008-2013 Free Software Foundation, Inc. // diff --git a/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/not_equal.cc b/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/not_equal.cc index 7281c650dbc..fa5eea67bb6 100644 --- a/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/not_equal.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/error_condition/operators/not_equal.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // Copyright (C) 2008-2013 Free Software Foundation, Inc. // diff --git a/libstdc++-v3/testsuite/20_util/is_compound/value.cc b/libstdc++-v3/testsuite/20_util/is_compound/value.cc index 20affbf21f4..936b7366663 100644 --- a/libstdc++-v3/testsuite/20_util/is_compound/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_compound/value.cc @@ -46,6 +46,9 @@ void test01() VERIFY( (test_category<is_compound, double>(false)) ); VERIFY( (test_category<is_compound, long double>(false)) ); + // libstdc++/56609 + VERIFY( (test_category<is_compound, std::nullptr_t>(false)) ); + // Sanity check. VERIFY( (test_category<is_compound, ClassType>(true)) ); } diff --git a/libstdc++-v3/testsuite/20_util/is_fundamental/value.cc b/libstdc++-v3/testsuite/20_util/is_fundamental/value.cc index da63d6042a3..00fa8822d38 100644 --- a/libstdc++-v3/testsuite/20_util/is_fundamental/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_fundamental/value.cc @@ -46,6 +46,9 @@ void test01() VERIFY( (test_category<is_fundamental, double>(true)) ); VERIFY( (test_category<is_fundamental, long double>(true)) ); + // libstdc++/56609 + VERIFY( (test_category<is_fundamental, std::nullptr_t>(true)) ); + // Sanity check. VERIFY( (test_category<is_fundamental, ClassType>(false)) ); } 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/map/56613.cc b/libstdc++-v3/testsuite/23_containers/map/56613.cc new file mode 100644 index 00000000000..98433598c6b --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/map/56613.cc @@ -0,0 +1,74 @@ +// -*- C++ -*- + +// 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 <testsuite_hooks.h> +#include <map> + +// { dg-do compile } +// { dg-options "-std=gnu++11" } + +// libstdc++/56613 +#include <map> + +// A conforming C++03 allocator, should still work in C++11 mode. +template<typename T> +struct alloc +{ + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef unsigned size_type; + typedef int difference_type; + + template<typename U> + struct rebind { + typedef alloc<U> other; + }; + + alloc() { } + template<typename U> + alloc(const alloc<U>&) { } + + pointer allocate(size_type n, const void* = 0) { return +std::allocator<T>().allocate(n); } + void deallocate(pointer p, size_type n) { std::allocator<T>().deallocate(p, +n); } + + size_type max_size() const { return -1; } + + void construct(pointer p, const T& t) { new ((void*) p) T(t); } + void destroy(pointer p) { p->~T(); } + + pointer address(reference x) const throw() { return &x; } + const_pointer address(const_reference x) const throw() { return &x; } +}; + +template<typename T, typename U> +bool operator==(alloc<T>, alloc<U>) { return true; } + +template<typename T, typename U> +bool operator!=(alloc<T>, alloc<U>) { return false; } + +int main() +{ + std::map<int, int, std::less<int>, alloc<int> > m; + m[1]; +} diff --git a/libstdc++-v3/testsuite/23_containers/set/requirements/exception/basic.cc b/libstdc++-v3/testsuite/23_containers/set/requirements/exception/basic.cc index d44327f6c10..2de0308d18f 100644 --- a/libstdc++-v3/testsuite/23_containers/set/requirements/exception/basic.cc +++ b/libstdc++-v3/testsuite/23_containers/set/requirements/exception/basic.cc @@ -1,4 +1,5 @@ // { dg-options "-std=gnu++0x" } +// { dg-additional-options "-static-libstdc++" { target *-*-mingw* } } // { dg-require-cstdint "" } // 2009-11-30 Benjamin Kosnik <benjamin@redhat.com> 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 aa7617365ea..64e46658bb8 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 *-*-* } 1236 } +// { dg-error "no matching" "" { target *-*-* } 1240 } #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 cc46be5805f..a8d98cb8092 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 *-*-* } 1277 } +// { dg-error "no matching" "" { target *-*-* } 1281 } #include <vector> diff --git a/libstdc++-v3/testsuite/26_numerics/headers/cmath/c99_classification_macros_c.cc b/libstdc++-v3/testsuite/26_numerics/headers/cmath/c99_classification_macros_c.cc index 12126040e1e..d7ad5fecf59 100644 --- a/libstdc++-v3/testsuite/26_numerics/headers/cmath/c99_classification_macros_c.cc +++ b/libstdc++-v3/testsuite/26_numerics/headers/cmath/c99_classification_macros_c.cc @@ -20,8 +20,8 @@ // { dg-do compile } // { dg-add-options no_pch } -// { dg-xfail-if "" { { *-*-linux* *-*-darwin* *-*-solaris2.1[0-9]* hppa*-*-hpux* } || { uclibc || newlib } } { "*" } { "" } } -// { dg-excess-errors "" { target { { *-*-linux* *-*-darwin* *-*-solaris2.1[0-9]* hppa*-*-hpux* } || { uclibc || newlib } } } } +// { dg-xfail-if "" { { *-*-linux* *-*-darwin* *-*-solaris2.1[0-9]* hppa*-*-hpux* *-*-mingw* } || { uclibc || newlib } } { "*" } { "" } } +// { dg-excess-errors "" { target { { *-*-linux* *-*-darwin* *-*-solaris2.1[0-9]* hppa*-*-hpux* *-*-mingw* } || { uclibc || newlib } } } } #include <math.h> 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/libstdc++-v3/testsuite/30_threads/packaged_task/cons/56492.cc b/libstdc++-v3/testsuite/30_threads/packaged_task/cons/56492.cc new file mode 100644 index 00000000000..02296bb5aa6 --- /dev/null +++ b/libstdc++-v3/testsuite/30_threads/packaged_task/cons/56492.cc @@ -0,0 +1,35 @@ +// { dg-do compile { target *-*-freebsd* *-*-netbsd* *-*-linux* *-*-solaris* *-*-cygwin *-*-darwin* powerpc-ibm-aix* } } +// { dg-options " -std=gnu++11 -pthread" { target *-*-freebsd* *-*-netbsd* *-*-linux* powerpc-ibm-aix* } } +// { dg-options " -std=gnu++11 -pthreads" { target *-*-solaris* } } +// { dg-options " -std=gnu++11 " { target *-*-cygwin *-*-darwin* } } +// { dg-require-cstdint "" } +// { dg-require-gthreads "" } +// { dg-require-atomic-builtins "" } + +// 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 <future> + +struct S +{ + S() = default; + S(S&&) = default; + void operator()() { } +}; + +std::packaged_task<void ()> pt{ S{} }; diff --git a/libstdc++-v3/testsuite/ext/debug_allocator/56170.cc b/libstdc++-v3/testsuite/ext/debug_allocator/56170.cc new file mode 100644 index 00000000000..217fc323baf --- /dev/null +++ b/libstdc++-v3/testsuite/ext/debug_allocator/56170.cc @@ -0,0 +1,27 @@ +// 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/>. + +// { dg-do compile } + +#include <list> +#include <vector> +#include <ext/debug_allocator.h> + +using __gnu_cxx::debug_allocator; + +template class std::list<int, debug_allocator<std::allocator<int> > >; +template class std::vector<int, debug_allocator<std::allocator<int> > >; diff --git a/libstdc++-v3/testsuite/lib/dg-options.exp b/libstdc++-v3/testsuite/lib/dg-options.exp index d15fc219ae8..e2640ee98ee 100644 --- a/libstdc++-v3/testsuite/lib/dg-options.exp +++ b/libstdc++-v3/testsuite/lib/dg-options.exp @@ -218,3 +218,25 @@ proc add_options_for_no_pch { flags } { # This forces any generated and possibly included PCH to be invalid. return "-D__GLIBCXX__=99999999" } + +# Like dg-options, but adds to the default options rather than replacing them. + +proc dg-additional-options { args } { + upvar dg-extra-tool-flags extra-tool-flags + + if { [llength $args] > 3 } { + error "[lindex $args 0]: too many arguments" + return + } + + if { [llength $args] >= 3 } { + switch [dg-process-target [lindex $args 2]] { + "S" { eval lappend extra-tool-flags [lindex $args 1] } + "N" { } + "F" { error "[lindex $args 0]: `xfail' not allowed here" } + "P" { error "[lindex $args 0]: `xfail' not allowed here" } + } + } else { + eval lappend extra-tool-flags [lindex $args 1] + } +} 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 |