From ef5c0ad1f0be177c654766e31c63142a03378a66 Mon Sep 17 00:00:00 2001 From: hjl Date: Fri, 23 Apr 2010 12:26:09 +0000 Subject: [PATCH] Merged r158465 through r158660 into branch. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/ifunc@158664 138bc75d-0d04-0410-961f-82ee72b054a4 --- ChangeLog | 5 + configure | 2 +- configure.ac | 2 +- contrib/ChangeLog | 4 + contrib/gcc_update | 6 + gcc/ChangeLog | 619 ++++++++++++- gcc/DATESTAMP | 2 +- gcc/Makefile.in | 5 - gcc/ada/ChangeLog | 33 + gcc/ada/gcc-interface/decl.c | 207 +++-- gcc/ada/gcc-interface/misc.c | 19 +- gcc/ada/gcc-interface/utils.c | 24 +- gcc/ada/gcc-interface/utils2.c | 34 +- gcc/ada/gsocket.h | 3 +- gcc/ada/uintp.h | 4 + gcc/builtins.c | 88 +- gcc/builtins.def | 6 +- gcc/c-decl.c | 2 +- gcc/c-parser.c | 43 +- gcc/c-tree.h | 10 +- gcc/c-typeck.c | 161 ++-- gcc/cfgexpand.c | 25 +- gcc/cgraph.c | 11 +- gcc/cgraph.h | 6 +- gcc/cgraphunit.c | 13 +- gcc/config/arm/arm.md | 16 +- gcc/config/arm/bpabi-v6m.S | 10 + gcc/config/arm/bpabi.S | 10 + gcc/config/arm/crti.asm | 9 + gcc/config/arm/crtn.asm | 10 + gcc/config/arm/lib1funcs.asm | 4 +- gcc/config/arm/libunwind.S | 10 + gcc/config/avr/avr-devices.c | 49 +- gcc/config/avr/t-avr | 47 +- gcc/config/i386/i386.c | 72 +- gcc/config/i386/i386.md | 492 +++++------ gcc/config/ia64/ia64.c | 3 + gcc/config/ia64/ia64.h | 4 +- gcc/config/rs6000/x-aix | 2 +- gcc/config/s390/s390.c | 24 +- gcc/config/sh/sh.c | 17 + gcc/config/stormy16/stormy16-lib2-ucmpsi2.c | 2 + gcc/config/stormy16/stormy16-lib2.c | 25 +- gcc/config/stormy16/stormy16.c | 2 +- gcc/config/stormy16/stormy16.h | 329 ++----- gcc/config/stormy16/stormy16.md | 33 - gcc/config/stormy16/t-stormy16 | 5 +- gcc/configure | 6 +- gcc/configure.ac | 4 +- gcc/cp/ChangeLog | 38 + gcc/cp/cp-tree.h | 12 +- gcc/cp/cvt.c | 2 + gcc/cp/decl.c | 4 +- gcc/cp/init.c | 9 +- gcc/cp/typeck.c | 26 +- gcc/df-problems.c | 21 +- gcc/df.h | 1 + gcc/dojump.c | 3 +- gcc/double-int.c | 12 + gcc/double-int.h | 1 + gcc/dwarf2out.c | 139 ++- gcc/emit-rtl.c | 12 +- gcc/expmed.c | 53 +- gcc/expr.c | 201 ++--- gcc/fold-const.c | 41 +- gcc/fortran/ChangeLog | 58 ++ gcc/fortran/f95-lang.c | 5 +- gcc/fortran/gfortran.texi | 4 +- gcc/fortran/intrinsic.c | 2 +- gcc/fortran/openmp.c | 29 +- gcc/fortran/resolve.c | 36 +- gcc/fortran/trans-array.c | 32 +- gcc/fortran/trans-decl.c | 3 +- gcc/fortran/trans.c | 1 - gcc/fortran/trans.h | 1 - gcc/gcc.c | 2 +- gcc/gimple-fold.c | 2 +- gcc/gimple.h | 1 + gcc/gimplify.c | 31 +- gcc/ifcvt.c | 73 +- gcc/ipa-cp.c | 3 +- gcc/ipa-inline.c | 29 +- gcc/ipa-prop.c | 6 +- gcc/ipa-pure-const.c | 3 +- gcc/ipa-reference.c | 3 +- gcc/ipa.c | 5 +- gcc/ira-color.c | 4 +- gcc/ira-lives.c | 3 + gcc/java/ChangeLog | 5 + gcc/java/decl.c | 2 +- gcc/lambda-code.c | 84 +- gcc/lambda-mat.c | 73 +- gcc/lambda-trans.c | 16 +- gcc/lambda.h | 11 +- gcc/lto-cgraph.c | 83 +- gcc/lto-section-in.c | 1 - gcc/lto-section-out.c | 42 - gcc/lto-streamer-out.c | 6 +- gcc/lto-streamer.c | 3 - gcc/lto-streamer.h | 4 - gcc/lto-wpa-fixup.c | 282 ------ gcc/lto/ChangeLog | 28 + gcc/lto/lto-lang.c | 2 +- gcc/lto/lto.c | 139 ++- gcc/omp-low.c | 28 +- gcc/optabs.c | 63 +- gcc/optabs.h | 3 + gcc/opts.c | 9 + gcc/passes.c | 118 ++- gcc/po/ChangeLog | 8 + gcc/po/es.po | 203 ++--- gcc/po/zh_CN.po | 195 ++-- gcc/reginfo.c | 2 + gcc/rtl.h | 1 + gcc/simplify-rtx.c | 69 +- gcc/stor-layout.c | 72 +- gcc/testsuite/ChangeLog | 190 +++- gcc/testsuite/g++.dg/debug/dwarf2/enum1.C | 19 + gcc/testsuite/g++.dg/debug/dwarf2/rv1.C | 15 + gcc/testsuite/g++.dg/init/member1.C | 2 +- gcc/testsuite/g++.dg/other/fold1.C | 2 +- gcc/testsuite/g++.dg/parse/crash36.C | 2 +- gcc/testsuite/g++.dg/template/recurse2.C | 7 + gcc/testsuite/g++.dg/template/typedef32.C | 46 + gcc/testsuite/g++.dg/template/typedef33.C | 21 + gcc/testsuite/g++.dg/torture/pr39417.C | 56 ++ gcc/testsuite/g++.dg/tree-ssa/fold-compare.C | 28 + gcc/testsuite/g++.dg/vect/pr43771.cc | 14 + gcc/testsuite/gcc.c-torture/compile/pr43635.c | 7 + gcc/testsuite/gcc.c-torture/compile/pr43845.c | 12 + gcc/testsuite/gcc.c-torture/execute/pr43783.c | 21 + .../gcc.dg/cproj-fails-with-broken-glibc.c | 25 + gcc/testsuite/gcc.dg/graphite/interchange-0.c | 2 +- gcc/testsuite/gcc.dg/ipa/ipa-pta-11.c | 2 +- gcc/testsuite/gcc.dg/ipa/ipa-pta-14.c | 32 + gcc/testsuite/gcc.dg/torture/builtin-cproj-1.c | 175 ++++ gcc/testsuite/gcc.dg/torture/builtin-cproj-2.c | 46 + gcc/testsuite/gcc.dg/vect/pr37027.c | 37 + gcc/testsuite/gcc.dg/vect/pr43842.c | 55 ++ gcc/testsuite/gcc.dg/vect/slp-reduc-1.c | 49 + gcc/testsuite/gcc.dg/vect/slp-reduc-2.c | 44 + gcc/testsuite/gcc.dg/vect/slp-reduc-3.c | 62 ++ gcc/testsuite/gcc.dg/vect/slp-reduc-4.c | 60 ++ gcc/testsuite/gcc.dg/vect/slp-reduc-5.c | 49 + gcc/testsuite/gcc.dg/vect/slp-reduc-6.c | 50 ++ gcc/testsuite/gcc.target/arm/wmul-1.c | 18 + gcc/testsuite/gcc.target/arm/wmul-2.c | 12 + gcc/testsuite/gcc.target/bfin/wmul-1.c | 18 + gcc/testsuite/gcc.target/bfin/wmul-2.c | 12 + gcc/testsuite/gcc.target/i386/pr43662.c | 24 + gcc/testsuite/gcc.target/i386/pr43766.c | 10 + gcc/testsuite/gcc.target/i386/wmul-1.c | 19 + gcc/testsuite/gcc.target/i386/wmul-2.c | 13 + gcc/testsuite/gfortran.dg/abstract_type_6.f03 | 53 ++ gcc/testsuite/gfortran.dg/assign_10.f90 | 8 +- gcc/testsuite/gfortran.dg/bounds_check_fail_3.f90 | 2 +- gcc/testsuite/gfortran.dg/bounds_check_fail_4.f90 | 2 +- gcc/testsuite/gfortran.dg/gomp/pr43337.f90 | 30 + gcc/testsuite/gfortran.dg/gomp/pr43836.f90 | 10 + gcc/testsuite/gfortran.dg/gomp/sharing-2.f90 | 12 +- gcc/testsuite/gfortran.dg/pr43796.f90 | 51 ++ gcc/testsuite/gfortran.dg/proc_decl_23.f90 | 43 + gcc/testsuite/gfortran.dg/reassoc_6.f | 20 + gcc/testsuite/gfortran.dg/vector_subscript_6.f90 | 33 + gcc/testsuite/gnat.dg/rep_clause5.adb | 39 + gcc/testsuite/gnat.dg/rep_clause5.ads | 12 + gcc/testsuite/gnat.dg/rep_clause5_pkg.ads | 383 ++++++++ .../gnat.dg/{sizetype.adb => sizetype1.adb} | 2 +- gcc/testsuite/gnat.dg/sizetype2.adb | 27 + gcc/testsuite/lib/prune.exp | 1 + gcc/testsuite/lib/target-supports.exp | 19 + gcc/timevar.def | 1 - gcc/tree-cfg.c | 7 +- gcc/tree-data-ref.c | 10 +- gcc/tree-data-ref.h | 4 +- gcc/tree-dfa.c | 6 +- gcc/tree-loop-distribution.c | 9 +- gcc/tree-loop-linear.c | 5 +- gcc/tree-nested.c | 5 +- gcc/tree-object-size.c | 3 +- gcc/tree-parloops.c | 12 +- gcc/tree-pass.h | 17 +- gcc/tree-predcom.c | 16 +- gcc/tree-sra.c | 10 +- gcc/tree-ssa-address.c | 6 +- gcc/tree-ssa-math-opts.c | 134 +++ gcc/tree-ssa-phiopt.c | 5 +- gcc/tree-ssa-phiprop.c | 5 +- gcc/tree-ssa-pre.c | 88 +- gcc/tree-ssa-reassoc.c | 37 +- gcc/tree-ssa-structalias.c | 73 +- gcc/tree-tailcall.c | 10 +- gcc/tree-vect-loop.c | 982 +++++++++++++-------- gcc/tree-vect-patterns.c | 10 +- gcc/tree-vect-slp.c | 405 +++++++-- gcc/tree-vect-stmts.c | 13 +- gcc/tree-vectorizer.h | 9 +- gcc/tree-vrp.c | 21 +- gcc/tree.c | 4 +- gcc/tree.h | 17 +- gcc/unwind-dw2-fde.c | 34 +- gcc/unwind-dw2.c | 11 +- gcc/varpool.c | 6 + include/ChangeLog | 4 + include/sha1.h | 4 +- libcpp/po/ChangeLog | 8 + libcpp/po/es.po | 6 +- libcpp/po/zh_CN.po | 8 +- libgomp/ChangeLog | 17 + libgomp/config/linux/affinity.c | 17 +- libgomp/config/linux/proc.c | 24 +- libgomp/sections.c | 20 +- libgomp/testsuite/libgomp.fortran/vla8.f90 | 254 ++++++ libjava/ChangeLog | 5 + libjava/configure | 33 + libjava/configure.ac | 15 + libstdc++-v3/ChangeLog | 17 + libstdc++-v3/doc/html/api.html | 35 +- libstdc++-v3/doc/html/bk02.html | 6 +- libstdc++-v3/doc/html/bk03.html | 6 +- libstdc++-v3/doc/html/faq.html | 16 +- libstdc++-v3/doc/html/manual/abi.html | 157 ++-- libstdc++-v3/doc/html/manual/algorithms.html | 70 +- libstdc++-v3/doc/html/manual/api.html | 14 +- .../doc/html/manual/appendix_contributing.html | 54 +- libstdc++-v3/doc/html/manual/appendix_free.html | 12 +- libstdc++-v3/doc/html/manual/appendix_gfdl.html | 8 +- libstdc++-v3/doc/html/manual/appendix_gpl.html | 12 +- libstdc++-v3/doc/html/manual/appendix_porting.html | 12 +- libstdc++-v3/doc/html/manual/associative.html | 113 ++- libstdc++-v3/doc/html/manual/atomics.html | 31 + libstdc++-v3/doc/html/manual/auto_ptr.html | 90 -- libstdc++-v3/doc/html/manual/backwards.html | 211 +++-- libstdc++-v3/doc/html/manual/bitmap_allocator.html | 14 +- libstdc++-v3/doc/html/manual/bitset.html | 105 --- libstdc++-v3/doc/html/manual/bk01ix01.html | 51 -- libstdc++-v3/doc/html/manual/bk01pt02.html | 46 + libstdc++-v3/doc/html/manual/bk01pt02ch04s02.html | 49 - libstdc++-v3/doc/html/manual/bk01pt02ch04s03.html | 29 - .../{bk01pt03ch08.html => bk01pt02ch05s02.html} | 9 +- libstdc++-v3/doc/html/manual/bk01pt02pr01.html | 17 - libstdc++-v3/doc/html/manual/bk01pt03ch07s02.html | 20 - libstdc++-v3/doc/html/manual/bk01pt03ch07s03.html | 4 - .../{bk01pt12ch30s02.html => bk01pt03ch17s02.html} | 6 +- libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html | 24 + .../{bk01pt12ch30s04.html => bk01pt03ch17s04.html} | 32 +- .../{bk01pt12ch31s02.html => bk01pt03ch18s02.html} | 4 +- .../{bk01pt12ch31s03.html => bk01pt03ch18s03.html} | 6 +- .../{bk01pt12ch31s04.html => bk01pt03ch18s04.html} | 10 +- .../{bk01pt12ch31s05.html => bk01pt03ch18s05.html} | 8 +- .../{bk01pt12ch32s02.html => bk01pt03ch19s02.html} | 22 +- .../{bk01pt12ch32s03.html => bk01pt03ch19s03.html} | 4 +- .../{bk01pt12ch32s04.html => bk01pt03ch19s04.html} | 4 +- .../{bk01pt12ch32s05.html => bk01pt03ch19s05.html} | 14 +- .../{bk01pt12ch32s06.html => bk01pt03ch19s06.html} | 16 +- .../{bk01pt12ch32s07.html => bk01pt03ch19s07.html} | 100 +-- .../{bk01pt12ch34s02.html => bk01pt03ch21s02.html} | 6 +- .../{bk01pt12ch34s03.html => bk01pt03ch21s03.html} | 4 +- .../{bk01pt12ch41s02.html => bk01pt03ch28s02.html} | 6 +- .../{bk01pt12ch41s03.html => bk01pt03ch28s03.html} | 7 +- .../{bk01pt12pr03.html => bk01pt03pr01.html} | 14 +- libstdc++-v3/doc/html/manual/bk01pt04.html | 21 + libstdc++-v3/doc/html/manual/bk01pt05ch13.html | 90 -- libstdc++-v3/doc/html/manual/bk01pt05ch13s02.html | 40 - libstdc++-v3/doc/html/manual/bk01pt05ch13s03.html | 57 -- libstdc++-v3/doc/html/manual/bk01pt05ch13s04.html | 79 -- libstdc++-v3/doc/html/manual/bk01pt05ch13s05.html | 16 - libstdc++-v3/doc/html/manual/bk01pt05ch13s06.html | 94 -- libstdc++-v3/doc/html/manual/bk01pt08ch19.html | 39 - libstdc++-v3/doc/html/manual/bk01pt08ch19s02.html | 86 -- libstdc++-v3/doc/html/manual/bk01pt09ch20.html | 19 - libstdc++-v3/doc/html/manual/bk01pt09pr02.html | 41 - libstdc++-v3/doc/html/manual/bk01pt10ch23s02.html | 19 - libstdc++-v3/doc/html/manual/bk01pt12ch30s03.html | 24 - libstdc++-v3/doc/html/manual/bugs.html | 270 +++--- libstdc++-v3/doc/html/manual/codecvt.html | 379 -------- libstdc++-v3/doc/html/manual/complex.html | 25 - libstdc++-v3/doc/html/manual/concurrency.html | 42 + libstdc++-v3/doc/html/manual/configure.html | 258 +++--- libstdc++-v3/doc/html/manual/containers.html | 64 +- libstdc++-v3/doc/html/manual/containers_and_c.html | 20 +- libstdc++-v3/doc/html/manual/debug.html | 33 +- libstdc++-v3/doc/html/manual/debug_mode.html | 8 +- libstdc++-v3/doc/html/manual/diagnostics.html | 52 +- .../doc/html/manual/documentation_style.html | 76 +- libstdc++-v3/doc/html/manual/dynamic_memory.html | 15 +- libstdc++-v3/doc/html/manual/exceptions.html | 22 - libstdc++-v3/doc/html/manual/ext_algorithms.html | 10 +- libstdc++-v3/doc/html/manual/ext_allocators.html | 80 +- .../doc/html/manual/ext_compile_checks.html | 6 +- libstdc++-v3/doc/html/manual/ext_concurrency.html | 16 +- libstdc++-v3/doc/html/manual/ext_containers.html | 6 +- libstdc++-v3/doc/html/manual/ext_demangling.html | 8 +- libstdc++-v3/doc/html/manual/ext_io.html | 58 +- libstdc++-v3/doc/html/manual/ext_iterators.html | 6 +- libstdc++-v3/doc/html/manual/ext_numerics.html | 6 +- libstdc++-v3/doc/html/manual/ext_utilities.html | 14 +- libstdc++-v3/doc/html/manual/extensions.html | 8 +- libstdc++-v3/doc/html/manual/facets.html | 723 ++++++++++++++- .../manual/{bk01pt11ch27s02.html => fstreams.html} | 77 +- libstdc++-v3/doc/html/manual/functors.html | 15 - .../doc/html/manual/fundamental_types.html | 43 - .../manual/generalized_numeric_operations.html | 11 +- libstdc++-v3/doc/html/manual/internals.html | 86 +- libstdc++-v3/doc/html/manual/intro.html | 2 +- .../html/manual/{iostream_objects.html => io.html} | 30 +- .../manual/{bk01pt11ch28s02.html => io_and_c.html} | 16 +- libstdc++-v3/doc/html/manual/iterators.html | 139 ++- libstdc++-v3/doc/html/manual/license.html | 4 +- .../manual/{locales.html => localization.html} | 69 +- libstdc++-v3/doc/html/manual/memory.html | 511 +++++++++-- libstdc++-v3/doc/html/manual/messages.html | 284 ------ libstdc++-v3/doc/html/manual/numerics.html | 39 +- libstdc++-v3/doc/html/manual/numerics_and_c.html | 22 +- libstdc++-v3/doc/html/manual/pairs.html | 11 +- libstdc++-v3/doc/html/manual/parallel_mode.html | 10 +- libstdc++-v3/doc/html/manual/profile_mode.html | 22 +- libstdc++-v3/doc/html/manual/sequences.html | 43 - libstdc++-v3/doc/html/manual/setup.html | 18 +- libstdc++-v3/doc/html/manual/shared_ptr.html | 304 ------- .../doc/html/manual/source_code_style.html | 92 +- .../doc/html/manual/source_organization.html | 12 +- libstdc++-v3/doc/html/manual/spine.html | 40 +- libstdc++-v3/doc/html/manual/status.html | 28 +- .../{bk01pt11ch25s02.html => streambufs.html} | 76 +- libstdc++-v3/doc/html/manual/strings.html | 375 +++++++- libstdc++-v3/doc/html/manual/stringstreams.html | 10 +- libstdc++-v3/doc/html/manual/support.html | 139 ++- libstdc++-v3/doc/html/manual/termination.html | 172 +++- libstdc++-v3/doc/html/manual/test.html | 10 +- libstdc++-v3/doc/html/manual/traits.html | 20 +- libstdc++-v3/doc/html/manual/using.html | 4 +- .../doc/html/manual/using_concurrency.html | 2 +- .../doc/html/manual/using_dynamic_or_shared.html | 26 +- libstdc++-v3/doc/html/manual/using_exceptions.html | 91 +- libstdc++-v3/doc/html/manual/using_headers.html | 12 +- libstdc++-v3/doc/html/manual/using_macros.html | 10 +- libstdc++-v3/doc/html/manual/utilities.html | 26 +- libstdc++-v3/doc/html/manual/vector.html | 13 - .../doc/html/manual/verbose_termination.html | 79 -- libstdc++-v3/doc/html/spine.html | 38 +- libstdc++-v3/doc/xml/faq.xml | 10 +- .../doc/xml/manual/appendix_contributing.xml | 2 +- libstdc++-v3/doc/xml/manual/prerequisites.xml | 6 + libstdc++-v3/doc/xml/manual/strings.xml | 4 + libstdc++-v3/doc/xml/manual/using.xml | 28 +- libstdc++-v3/include/parallel/partition.h | 146 ++- 347 files changed, 10531 insertions(+), 6396 deletions(-) create mode 100644 gcc/config/stormy16/stormy16-lib2-ucmpsi2.c delete mode 100644 gcc/lto-wpa-fixup.c create mode 100644 gcc/testsuite/g++.dg/debug/dwarf2/enum1.C create mode 100644 gcc/testsuite/g++.dg/debug/dwarf2/rv1.C create mode 100644 gcc/testsuite/g++.dg/template/recurse2.C create mode 100644 gcc/testsuite/g++.dg/template/typedef32.C create mode 100644 gcc/testsuite/g++.dg/template/typedef33.C create mode 100644 gcc/testsuite/g++.dg/torture/pr39417.C create mode 100644 gcc/testsuite/g++.dg/tree-ssa/fold-compare.C create mode 100644 gcc/testsuite/g++.dg/vect/pr43771.cc create mode 100644 gcc/testsuite/gcc.c-torture/compile/pr43635.c create mode 100644 gcc/testsuite/gcc.c-torture/compile/pr43845.c create mode 100644 gcc/testsuite/gcc.c-torture/execute/pr43783.c create mode 100644 gcc/testsuite/gcc.dg/cproj-fails-with-broken-glibc.c create mode 100644 gcc/testsuite/gcc.dg/ipa/ipa-pta-14.c create mode 100644 gcc/testsuite/gcc.dg/torture/builtin-cproj-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/builtin-cproj-2.c create mode 100644 gcc/testsuite/gcc.dg/vect/pr37027.c create mode 100644 gcc/testsuite/gcc.dg/vect/pr43842.c create mode 100644 gcc/testsuite/gcc.dg/vect/slp-reduc-1.c create mode 100644 gcc/testsuite/gcc.dg/vect/slp-reduc-2.c create mode 100644 gcc/testsuite/gcc.dg/vect/slp-reduc-3.c create mode 100644 gcc/testsuite/gcc.dg/vect/slp-reduc-4.c create mode 100644 gcc/testsuite/gcc.dg/vect/slp-reduc-5.c create mode 100644 gcc/testsuite/gcc.dg/vect/slp-reduc-6.c create mode 100644 gcc/testsuite/gcc.target/arm/wmul-1.c create mode 100644 gcc/testsuite/gcc.target/arm/wmul-2.c create mode 100644 gcc/testsuite/gcc.target/bfin/wmul-1.c create mode 100644 gcc/testsuite/gcc.target/bfin/wmul-2.c create mode 100644 gcc/testsuite/gcc.target/i386/pr43662.c create mode 100644 gcc/testsuite/gcc.target/i386/pr43766.c create mode 100644 gcc/testsuite/gcc.target/i386/wmul-1.c create mode 100644 gcc/testsuite/gcc.target/i386/wmul-2.c create mode 100644 gcc/testsuite/gfortran.dg/abstract_type_6.f03 create mode 100644 gcc/testsuite/gfortran.dg/gomp/pr43337.f90 create mode 100644 gcc/testsuite/gfortran.dg/gomp/pr43836.f90 create mode 100644 gcc/testsuite/gfortran.dg/pr43796.f90 create mode 100644 gcc/testsuite/gfortran.dg/proc_decl_23.f90 create mode 100644 gcc/testsuite/gfortran.dg/reassoc_6.f create mode 100644 gcc/testsuite/gfortran.dg/vector_subscript_6.f90 create mode 100644 gcc/testsuite/gnat.dg/rep_clause5.adb create mode 100644 gcc/testsuite/gnat.dg/rep_clause5.ads create mode 100644 gcc/testsuite/gnat.dg/rep_clause5_pkg.ads rename gcc/testsuite/gnat.dg/{sizetype.adb => sizetype1.adb} (91%) create mode 100644 gcc/testsuite/gnat.dg/sizetype2.adb create mode 100644 libgomp/testsuite/libgomp.fortran/vla8.f90 rewrite libstdc++-v3/doc/html/bk02.html (65%) rewrite libstdc++-v3/doc/html/bk03.html (68%) rewrite libstdc++-v3/doc/html/manual/algorithms.html (86%) create mode 100644 libstdc++-v3/doc/html/manual/atomics.html delete mode 100644 libstdc++-v3/doc/html/manual/auto_ptr.html delete mode 100644 libstdc++-v3/doc/html/manual/bitset.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01ix01.html create mode 100644 libstdc++-v3/doc/html/manual/bk01pt02.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt02ch04s02.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt02ch04s03.html rename libstdc++-v3/doc/html/manual/{bk01pt03ch08.html => bk01pt02ch05s02.html} (61%) delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt02pr01.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt03ch07s02.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt03ch07s03.html rename libstdc++-v3/doc/html/manual/{bk01pt12ch30s02.html => bk01pt03ch17s02.html} (92%) create mode 100644 libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html rename libstdc++-v3/doc/html/manual/{bk01pt12ch30s04.html => bk01pt03ch17s04.html} (96%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch31s02.html => bk01pt03ch18s02.html} (82%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch31s03.html => bk01pt03ch18s03.html} (95%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch31s04.html => bk01pt03ch18s04.html} (95%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch31s05.html => bk01pt03ch18s05.html} (84%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch32s02.html => bk01pt03ch19s02.html} (86%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch32s03.html => bk01pt03ch19s03.html} (80%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch32s04.html => bk01pt03ch19s04.html} (80%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch32s05.html => bk01pt03ch19s05.html} (88%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch32s06.html => bk01pt03ch19s06.html} (89%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch32s07.html => bk01pt03ch19s07.html} (94%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch34s02.html => bk01pt03ch21s02.html} (89%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch34s03.html => bk01pt03ch21s03.html} (92%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch41s02.html => bk01pt03ch28s02.html} (92%) rename libstdc++-v3/doc/html/manual/{bk01pt12ch41s03.html => bk01pt03ch28s03.html} (63%) rename libstdc++-v3/doc/html/manual/{bk01pt12pr03.html => bk01pt03pr01.html} (81%) create mode 100644 libstdc++-v3/doc/html/manual/bk01pt04.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt05ch13.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt05ch13s02.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt05ch13s03.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt05ch13s04.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt05ch13s05.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt05ch13s06.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt08ch19.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt08ch19s02.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt09ch20.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt09pr02.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt10ch23s02.html delete mode 100644 libstdc++-v3/doc/html/manual/bk01pt12ch30s03.html delete mode 100644 libstdc++-v3/doc/html/manual/codecvt.html delete mode 100644 libstdc++-v3/doc/html/manual/complex.html create mode 100644 libstdc++-v3/doc/html/manual/concurrency.html rewrite libstdc++-v3/doc/html/manual/containers.html (87%) rewrite libstdc++-v3/doc/html/manual/diagnostics.html (86%) delete mode 100644 libstdc++-v3/doc/html/manual/exceptions.html rename libstdc++-v3/doc/html/manual/{bk01pt11ch27s02.html => fstreams.html} (52%) delete mode 100644 libstdc++-v3/doc/html/manual/functors.html delete mode 100644 libstdc++-v3/doc/html/manual/fundamental_types.html rename libstdc++-v3/doc/html/manual/{iostream_objects.html => io.html} (66%) rename libstdc++-v3/doc/html/manual/{bk01pt11ch28s02.html => io_and_c.html} (53%) rewrite libstdc++-v3/doc/html/manual/iterators.html (85%) rename libstdc++-v3/doc/html/manual/{locales.html => localization.html} (65%) delete mode 100644 libstdc++-v3/doc/html/manual/messages.html rewrite libstdc++-v3/doc/html/manual/numerics.html (87%) delete mode 100644 libstdc++-v3/doc/html/manual/sequences.html delete mode 100644 libstdc++-v3/doc/html/manual/shared_ptr.html rename libstdc++-v3/doc/html/manual/{bk01pt11ch25s02.html => streambufs.html} (51%) rewrite libstdc++-v3/doc/html/manual/strings.html (85%) rewrite libstdc++-v3/doc/html/manual/support.html (88%) rewrite libstdc++-v3/doc/html/manual/termination.html (60%) rewrite libstdc++-v3/doc/html/manual/traits.html (74%) rewrite libstdc++-v3/doc/html/manual/utilities.html (91%) delete mode 100644 libstdc++-v3/doc/html/manual/vector.html delete mode 100644 libstdc++-v3/doc/html/manual/verbose_termination.html diff --git a/ChangeLog b/ChangeLog index 155e1abe374..8a1a4c71668 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2010-04-20 Eric Botcazou + + * configure.ac (BUILD_CONFIG): Redirect output to /dev/null. + * configure: Regenerate. + 2010-04-17 Ralf Corsépius * configure.ac (*-*-rtems*): Add target-libiberty to $skipdirs. diff --git a/configure b/configure index c8c60593155..91986d8b971 100755 --- a/configure +++ b/configure @@ -7665,7 +7665,7 @@ else mv conftest.o conftest.o.g0 && ${CC} -c -g conftest.c && mv conftest.o conftest.o.g && - ${srcdir}/contrib/compare-debug conftest.o.g0 conftest.o.g; then + ${srcdir}/contrib/compare-debug conftest.o.g0 conftest.o.g > /dev/null 2>&1; then : else BUILD_CONFIG= diff --git a/configure.ac b/configure.ac index 34308c212c5..c46fc4d9946 100644 --- a/configure.ac +++ b/configure.ac @@ -2720,7 +2720,7 @@ else mv conftest.o conftest.o.g0 && ${CC} -c -g conftest.c && mv conftest.o conftest.o.g && - ${srcdir}/contrib/compare-debug conftest.o.g0 conftest.o.g; then + ${srcdir}/contrib/compare-debug conftest.o.g0 conftest.o.g > /dev/null 2>&1; then : else BUILD_CONFIG= diff --git a/contrib/ChangeLog b/contrib/ChangeLog index ea62ec4f2b1..3a5f8f56597 100644 --- a/contrib/ChangeLog +++ b/contrib/ChangeLog @@ -1,3 +1,7 @@ +2010-04-22 Basile Starynkevitch + + * gcc_update: Sets the locale to C. + 2010-04-06 Joseph Myers * gennews (files): Add files for GCC 4.5. diff --git a/contrib/gcc_update b/contrib/gcc_update index 3e5a842338c..37e65af59c4 100755 --- a/contrib/gcc_update +++ b/contrib/gcc_update @@ -43,6 +43,12 @@ GCC_SVN=${GCC_SVN-${SVN-svn}} # Default options used when updating via SVN (none). UPDATE_OPTIONS="" +# Set the locale to C to make this script work for users with foreign +# locale like e.g. French UTF-8. +LANG=C +LC_ALL=C +export LANG LC_ALL + ######## Anything below shouldn't be changed by regular users. # Arrange for the value of $0 to be available for functions diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 700faedc68d..3d8c5b0272e 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,601 @@ +2010-04-22 Kaz Kojima + + PR target/43744 + * config/sh/sh.c (find_barrier): Don't emit a constant pool + in the middle of insns for casesi_worker_2. + +2010-04-22 David Edelsohn + + * config/rs6000/x-aix: Override LDFLAGS for all COMPILERS. + +2010-04-22 Ira Rosen + + PR tree-optimization/43842 + * tree-vect-loop.c (vect_create_epilog_for_reduction): Handle + loop unrolling in update of exit phis. Fix comment. + * tree-vect-slp.c (vect_analyze_slp): Check that there are at + least two reduction statements in the loop before starting SLP + analysis. + +2010-04-22 Nick Clifton + + * config/stormy16/stormy16-lib2.c (__ucmpsi2): Fix thinko. + +2010-04-22 Alexander Monakov + + * tree-ssa-reassoc.c (eliminate_plus_minus_pair): Handle BIT_NOT_EXPR + to simplify a + ~a. + +2010-04-22 Laurynas Biveinis + + * tree-parloops.c (loop_parallel_p): New argument + parloop_obstack. Pass it down. + (parallelize_loops): New variable parloop_obstack. Initialize it, + pass it down, free it. + + * tree-loop-linear.c (linear_transform_loops): Pass down + lambda_obstack. + + * tree-data-ref.h (lambda_compute_access_matrices): New argument + of type struct obstack *. + + * tree-data-ref.c (analyze_subscript_affine_affine): New variable + scratch_obstack. Initialize it, pass down, free it. + + * lambda.h (lambda_loop_new): Remove. + (lambda_matrix_new, lambda_matrix_inverse) + (lambda_trans_matrix_new, lambda_trans_matrix_inverse): New + argument of type struct obstack *. + + * lambda-trans.c (lambda_trans_matrix_new): New argument + lambda_obstack. Pass it down, use obstack allocation for ret. + (lambda_trans_matrix_inverse): New argument lambda_obstack. Pass + it down. + + * lambda-mat.c (lambda_matrix_get_column) + (lambda_matrix_project_to_null): Remove. + (lambda_matrix_new): New argument lambda_obstack. Use obstack + allocation for mat. + (lambda_matrix_inverse_hard, lambda_matrix_inverse): New argument + lambda_obstack. + + * lambda-code.c (lambda_loop_new): New function. + (lambda_lattice_new, compute_nest_using_fourier_motzkin) + (lambda_compute_auxillary_space, lambda_compute_target_space) + (lambda_loopnest_transform, gcc_loop_to_lambda_loop) + (lambda_loopnest_to_gcc_loopnest): Pass down lambda_obstack. + (build_access_matrix): New argument lambda_obstack. Use obstack + allocation for am. + (lambda_compute_step_signs, lambda_compute_access_matrices): New + argument lambda_obstack. Pass it down. + +2010-04-22 Bernd Schmidt + + * optabs.h (expand_widening_mult): Declare. + +2010-04-22 Richard Guenther + + PR tree-optimization/43845 + * tree-ssa-pre.c (create_component_ref_by_pieces_1): Properly + lookup the CALL_EXPR function and arguments. + +2010-04-22 Nick Clifton + + * config/stormy16/stormy16.c + (xstormy16_asm_output_aligned_common): Handle a NULL decl parameter. + * config/stormy16/stormy16.h: Tidy up formatting. + (DONT_USE_BUILTIN_SETJMP): Remove definition. + * config/stormy16/stormy16.c (cbranchsi4): Delete pattern. + (ineqbranchsi): Delete pattern. + * config/stormy16/stormy16-lib2-ucmpsi2.c: New file. + * config/stormy16/stormy16-lib2.c (__ucmpsi2): New function. + * config/stormy16/t-stormy16 (LIB2FUNCS_EXTRA): Add + stormy16-lib2-ucmpsi2.c. + +2010-04-22 Bernd Schmidt + + * ifcvt.c (dead_or_predicable): Use df_simulate_find_defs and + df_simulate_find_noclobber_defs as appropriate. Keep track of an + extra set merge_set_noclobber, and use it to relax the final test + slightly. + * df.h (df_simulate_find_noclobber_defs): Declare. + * df-problems.c (df_simulate_find_defs): Don't ignore partial or + conditional defs. + (df_simulate_find_noclobber_defs): New function. + +2010-04-22 Uros Bizjak + + * config/i386/i386.md: Use {} around multi-line preparation statements. + +2010-04-22 Laurynas Biveinis + + * c-tree.h (push_init_level, pop_init_level, set_init_index) + (process_init_element): New argument of type struct obstack *. + + * c-typeck.c (push_init_level, pop_init_level, set_designator) + (set_init_index, set_init_label, set_nonincremental_init) + (set_nonincremental_init_from_string, find_init_member) + (output_init_element, output_pending_init_elements) + (process_init_element): New argument braced_init_obstack. Pass it + down. + (push_range_stack, add_pending_init): New argument + braced_init_obstack. Use obstack allocation. + + * c-parser.c (c_parser_initelt, c_parser_initval): New argument + braced_init_obstack. Pass it down. + (c_parser_braced_init): New variables ret, braced_init_obstack. + Initialize obstack, pass it down and finally free it. + +2010-04-22 Bernd Schmidt + + PR middle-end/29274 + * tree-pass.h (pass_optimize_widening_mul): Declare. + * tree-ssa-math-opts.c (execute_optimize_widening_mul, + gate_optimize_widening_mul): New static functions. + (pass_optimize_widening_mul): New. + * expr.c (expand_expr_real_2) : New + case. + : Remove support for widening multiplies. + * tree.def (WIDEN_MULT_EXPR): Tweak comment. + * cfgexpand.c (expand_debug_expr) : Use + simplify_gen_unary rather than directly building extensions. + * tree-cfg.c (verify_gimple_assign_binary): Add tests for + WIDEN_MULT_EXPR. + * expmed.c (expand_widening_mult): New function. + * passes.c (init_optimization_passes): Add pass_optimize_widening_mul. + +2010-04-21 Jan Hubicka + + * timevar.def (TV_WHOPR_WPA_FIXUP): Remove. + * lto-section-in.c (lto_section_name): Remove wpa_fixup. + * lto-wpa-fixup.c: Remove. + * Makefile.in (lto-wpa-fixup.o): Remove. + * passes.c (init_optimization_passes): Remove pass_ipa_lto_wpa_fixup. + (execute_all_ipa_transforms): Set cgraph_state to CGRAPH_STATE_IPA_SSA. + * lto-streamer.c (lto_get_section_name): Remove wpa_fixup section. + +2010-04-21 Jan Hubicka + + * tree-pass.h (ipa_opt_pass_d): Rename function_read_summary; + add write_optimization_summary, read_optimization_summary. + (ipa_write_summaries_of_cgraph_node_set): Remove. + (ipa_write_optimization_summaries): Declare. + (ipa_read_optimization_summaries): Declare. + * ipa-cp.c (pass_ipa_cp): Update. + * ipa-reference.c (pass_ipa_reference): Update. + * ipa-pure-const.c (pass_ipa_pure_const): Update. + * lto-streamer-out.c (pass_ipa_lto_gimple, pass_ipa_lto_finish): + Update. + * ipa-inline.c (pass_ipa_inline): Update. + * ipa.c (pass_ipa_whole_program): Update. + * lto-wpa-fixup.c (pass_ipa_lto_wpa_fixup): Update. + * passes.c (ipa_write_summaries_1): Do not test wpa. + (ipa_write_optimization_summaries_1): New. + (ipa_write_optimization_summaries): New. + (ipa_read_summaries): Do not test ltrans. + (ipa_read_optimization_summaries_1): New. + (ipa_read_optimization_summaries): New. + +2010-04-21 Jan Hubicka + + * lto-cgraph.c (lto_output_node): Do not output comdat groups + for boundary nodes. + (output_cgraph): Do not arrange comdat groups for boundary nodes. + +2010-04-21 Jakub Jelinek + + PR debug/40040 + * dwarf2out.c (add_name_and_src_coords_attributes): Add + DW_AT_{,MIPS_}linkage_name even for Fortran decls. + +2010-04-21 Jan Hubicka + + * ipa-prop.c (ipa_edge_removal_hook): Check for bounds. + +2010-04-21 Jan Hubicka + + * varpool.c (decide_is_variable_needed): Variable is always needed + during ltrans. + +2010-04-21 Jan Hubicka + + * opts.c (decode_options): Enable pure-const pass for whopr. + +2010-04-21 Jan Hubicka + + * cgraph.c (dump_cgraph_node): Dump also assembler name. + * ipa-inline.c (cgraph_decide_inlining_of_small_functions): Do not ice + at WPA dumping. + (cgraph_decide_inlining): Do not expect callee to be removed in all + cases. + +2010-04-21 Eric B. Weddington + + * config/avr/avr-devices.c (avr_mcu_types): Add missing comma. + +2010-04-21 Uros Bizjak + + * config/i386/i386.md (x86_shrd): Add athlon_decode and + amdfam10_decode attributes. + +2010-04-21 Jakub Jelinek + + PR middle-end/43570 + * omp-low.c (scan_sharing_clauses): Don't scan_omp_op + OMP_CLAUSE_DECL for OMP_CLAUSE_COPYPRIVATE. + (lower_copyprivate_clauses): Use private var in outer + context instead of original var. Make sure the types + are correct for VLAs. + +2010-04-21 Richard Guenther + + * tree-ssa-structalias.c (do_ds_constraint): Avoid escaping + to non-pointer objects. + +2010-04-21 Jakub Jelinek + + * dwarf2out.c (add_var_loc_to_decl): Add LABEL argument. Drop + last chain entry if it starts with the still current label. + (add_location_or_const_value_attribute): Check that + loc_list->first->next is NULL instead of comparing ->first with ->last. + (dwarf2out_var_location): Pass last_label resp. last_postcall_label + to add_var_loc_to_decl. + + * dwarf2out.c (output_call_frame_info): For dw_cie_version + >= 4 add also address size and segment size fields into CIE header. + + * unwind-dw2.c (extract_cie_info): Handle CIE version 4, as + long as address size is the same as sizeof (void *) and + segment size is 0. + * unwind-dw2-fde.c (get_cie_encoding): Likewise. If + address size or segment size is unexpected, return DW_EH_PE_omit. + (classify_object_over_fdes): If get_cie_encoding returned + DW_EH_PE_omit, return -1. + (init_object): If classify_object_over_fdes returned -1, + pretend there were no FDEs at all. + +2010-04-21 Uros Bizjak + + * config/i386/i386.md (bswap2): Macroize expander from + bswap{si,di}2 using SWI48 mode iterator. + (*bswap2_movbe): Macroize insn from *bswap{si,di}_movbe using + SWI48 mode iterator. Set type attribute of bswap insn to bitmanip, + set modrm attribute of bswap insn to 0 and remove length attribute. + (*bswap2_1): Macroize insn from *bswap{si,di}_1 using SWI48 mode + iterator. Set type attribute to bitmanip, set modrm attribute to 0, + set mode attribute to and remove length attribute. + +2010-04-20 James E. Wilson + + PR rtl-optimization/43520 + * ira-lives.c (ira_implicitly_set_insn_hard_regs): Exclude classes with + zero available registers. + +2010-04-20 Kaveh R. Ghazi + + * builtins.c (fold_builtin_cproj): Fold more cases. + +2010-04-20 Kaveh R. Ghazi + + * builtins.c (build_complex_cproj, fold_builtin_cproj): New. + (fold_builtin_1): Fold builtin cproj. + * builtins.def (BUILT_IN_CPROJ, BUILT_IN_CPROJF, BUILT_IN_CPROJL): + Use ATTR_CONST_NOTHROW_LIST. + +2010-04-20 Uros Bizjak + + * config/i386/i386.md (ffs2): Macroize expander from ffs_cmove + and ffsdi2 using SWI48 mode iterator. Expand SImode insn through + ffsi2_no_cmove for !TARGET_CMOVE. + (ffssi2_no_cmove): Rename from *ffs_no_cmove. Make public. + (ffssi2): Remove expander. + (*ffs_1): Macroize insn from *ffs{si,di} using SWI48 + mode iterator. + (ctz2): Ditto from ctz{si,di}2. + (clz2): Macroize expander from ctz{hi,si,di}2 using SWI248 + mode iterator. + (clz2_abm): Macroize insn from clz{hi,si,di}2_abm using SWI248 + mode iterator. + +2010-04-20 Jakub Jelinek + + * dwarf2out.c (AT_linkage_name): Define. + (clone_as_declaration): Handle DW_AT_linkage_name. + (add_name_and_src_coords_attributes): Use AT_linkage_name instead + of DW_AT_MIPS_linkage_name. + (move_linkage_attr): Likewise. + (dwarf2out_finish): Likewise. + +2010-04-20 Xinliang David Li + + PR middle-end/41952 + * fold-const.c (fold_comparison): New folding rule. + +2010-04-20 Anatoly Sokolov + + * double-int.h (double_int_setbit): Declare. + * double-int.c (double_int_setbit): New function. + * rtl.h (immed_double_int_const): Declare. + * emit-rtl.c (immed_double_int_const): New function. + * builtins.c (expand_builtin_signbit): Clean up, use double_int_* + and immed_double_int_const functions. + * optabs.c (expand_absneg_bit, expand_copysign_absneg, + expand_copysign_bit): (Ditto.). + * simplify-rtx.c (simplify_binary_operation_1): (Ditto.). + * tree-ssa-address.c (addr_for_mem_ref): (Ditto.). + * dojump.c (prefer_and_bit_test): (Ditto.). + * expr.c (convert_modes, reduce_to_bit_field_precision, + const_vector_from_tree): (Ditto.). + * expmed.c (mask_rtx, lshift_value): (Ditto.). + +2010-04-20 Jan Hubicka + + * cgraph.c (cgraph_remove_node): Kill bodies in other partitoin. + (dump_cgraph_node): Dump new flags. + * cgraph.h (struct cgraph_node): Add flags + reachable_from_other_partition and in_other_partition. + (cgraph_can_remove_if_no_direct_calls_p): Functions used by + other partition can not be removed. + * cgraphunit.c (cgraph_mark_functions_to_output): Functions used by + the other partition must be output; silence sanity checking on + leaking functions bodies from other paritition. + * lto-cgraph.c (reachable_from_other_partition_p): New function. + (lto_output_node): Output new flags; do not sanity check that inline + clones are output; drop lto_forced_extern_inline_p code; do not mock + visibility flags at partition boundaries. + (add_node_to): New function. + (output_cgraph): Use it to sort functions so masters appear before + clones. + (input_overwrite_node): Input new flags. + * passes.c (ipa_write_summaries): Do not call + lto_new_extern_inline_states. + * lto-section-out.c (forced_extern_inline, lto_new_extern_inline_states, + lto_delete_extern_inline_states, lto_force_functions_extern_inline, + lto_forced_extern_inline_p): Kill. + * lto-streamer.h (lto_new_extern_inline_states, + * lto_delete_extern_inline_states, lto_force_functions_extern_inline, + lto_forced_extern_inline_p): Kill. + +2010-04-20 Richard Guenther + + * tree-ssa-structalias.c (do_sd_constraint): Add edges only + from vars that can have pointers. + (process_constraint): Dump useless constraints. + +2010-04-20 Richard Guenther + + * tree-ssa-structalias.c (do_structure_copy): Properly handle DEREF. + (dump_sa_points_to_info): Remove asserts. + (init_base_vars): nothing_id isn't an escape point nor does it + have pointers. + +2010-04-20 Jakub Jelinek + + * tree.h (TYPE_REF_IS_RVALUE): Define. + * dwarf2out.c (attr_checksum_ordered, is_type_die, is_comdat_die, + should_move_die_to_comdat, prune_unused_types_walk): Handle + DW_TAG_rvalue_reference_type like DW_TAG_reference_type. + (modified_type_die, gen_reference_type_die): Emit + DW_TAG_rvalue_reference_type instead of DW_TAG_reference_type + if TYPE_REF_IS_RVALUE and -gdwarf-4. + +2010-04-20 Andreas Krebbel + + PR target/43635 + * config/s390/s390.c (s390_emit_call): Turn direct into indirect + calls for -fpic -m31 if they have been sibcall optimized. + +2010-04-19 James E. Wilson + + * config/ia64/ia64.h (FIXED_REGISTERS, CALL_USED_REGISTERS): Make + ar.lc fixed and call-used. + + * config/ia64/ia64.c (TARGET_INVALID_WITHIN_DOLOOP): Define. + +2010-04-19 Jan Hubicka + + * opts.c (decode_options): Disable whpr incompatible passes. + * lto/lto.c (lto_1_to_1_map): Skip clones. + (read_cgraph_and_symbols): Do not mark everything as needed. + (do_whole_program_analysis): Do map only after optimizing; + set proper cgraph_state; use passmanager. + +2010-04-19 DJ Delorie + + * cfgexpand.c (expand_debug_expr): Check for mismatched modes in + POINTER_PLUS_EXPR and fix them. + +2010-04-19 Eric B. Weddington + + * config/avr/avr-devices.c (avr_mcu_types): Add support for new + devices atmega644pa, attiny2313a, attiny24a, attiny261a, attiny4313, + attiny44a, attiny861a, atmega16a, atmega168a, atmega164a, atmega165a, + atmega169a, atmega169pa, atmega16hva2, atmega324a, atmega324pa, + atmega325a, atmega3250a, atmega328, atmega329a, atmega329pa, + atmega3290a, atmega48a, atmega644a, atmega645a, atmega645p, + atmega6450a, atmega6450p, atmega649a, atmega649p, atmega6490a, + atmega6490p, atmega64hve, atmega88a, atmega88pa, attiny461a, attiny84a, + m3000. Remove support for devices atmega8m1, atmega8c1, atmega16c1, + atmega4hvd, atmega8hvd, attiny327, m3000f, m3000s, m3001b. + * config/avr/t-avr.c (MULTILIB_MATCHES): Same. + +2010-04-19 Eric Botcazou + + * ifcvt.c (noce_try_cmove_arith): Fix long lines. + (check_cond_move_block): Likewise. + (cond_move_process_if_block): Likewise. + (noce_find_if_block): Improve formatting. + (find_if_header): Pass 0 to memset and tweak conditions. + (cond_exec_find_if_block): Fix long lines and tweak conditions. + +2010-04-19 Jakub Jelinek + + * dwarf2out.c (lower_bound_default): For DW_LANG_Python return 0 + for -gdwarf-4. + + PR middle-end/43337 + * tree-nested.c (convert_nonlocal_omp_clauses): OMP_CLAUSE_PRIVATE + with non-local decl doesn't need chain. + +2010-04-19 Vladimir Makarov + + * ira-color.c (allocno_reload_assign): Avoid accumulating + reload registers in ALLOCNO_TOTAL_CONFLICT_HARD_REGS. + +2010-04-19 Martin Jambor + + * gimple.h (create_tmp_reg): Declare. + * gimplify.c (create_tmp_reg): New function. + (gimplify_return_expr): Use create_tmp_reg. + (gimplify_omp_atomic): Likewise. + (gimple_regimplify_operands): Likewise. + * tree-dfa.c (make_rename_temp): Likewise. + * tree-predcom.c (predcom_tmp_var): Likewise. + (reassociate_to_the_same_stmt): Likewise. + * tree-sra.c (replace_uses_with_default_def_ssa_name): Likewise. + (get_replaced_param_substitute): Likewise. + * tree-ssa-phiprop.c (phiprop_insert_phi): Likewise. + * tree-ssa-phiopt.c (cond_store_replacement): Likewise. + * tree-ssa-pre.c (get_representative_for): Likewise. + (create_expression_by_pieces): Likewise. + * tree-tailcall.c (adjust_return_value_with_ops): Likewise. + (create_tailcall_accumulator): Likewise. + +2010-04-19 Martin Jambor + + * cgraphunit.c (cgraph_redirect_edge_call_stmt_to_callee): Update + new_stmt. + (cgraph_materialize_all_clones): Assert !need_ssa_update_p. + +2010-04-19 Richard Guenther + + PR tree-optimization/43796 + * tree-vrp.c (adjust_range_with_scev): Lookup init and step + from SCEV in the lattice. + (vrp_visit_phi_node): Dump change. + +2010-04-19 Richard Guenther + + * configure.ac: Fix quoting around elf_getshstrndx ABI check. + * configure: Re-generated. + +2010-04-19 Richard Guenther + + PR tree-optimization/43783 + * tree-ssa-pre.c (create_component_ref_by_pieces_1): Drop + constant ARRAY_REF operands two and three if possible. + +2010-04-19 Uros Bizjak + + PR target/43766 + * config/i386/i386.c (ix86_decompose_address): Handle ASHIFT addends. + +2010-04-19 Jie Zhang + + PR target/43662 + * reginfo.c (reinit_regs): Set caller_save_initialized_p to false. + +2010-04-19 Ira Rosen + + PR tree-optimization/37027 + * tree-vectorizer.h (struct _loop_vec_info): Add new field reductions + and macro to access it. + (vectorizable_reduction): Add argument. + (vect_get_slp_defs): Likewise. + * tree-vect-loop.c (vect_analyze_scalar_cycles_1): Collect reduction + statements for possible use in SLP. + (new_loop_vec_info): Initialize LOOP_VINFO_REDUCTIONS. + (destroy_loop_vec_info): Free LOOP_VINFO_REDUCTIONS. + (vect_create_epilog_for_reduction): Handle SLP. Modify documentation, + add new argument. + (vectorizable_reduction): Likewise. + * tree-vect-stmts.c (vect_get_vec_defs): Update call to + vect_get_slp_defs. + (vectorizable_type_demotion, vectorizable_type_promotion, + vectorizable_store): Likewise. + (vect_analyze_stmt): Update call to vectorizable_reduction. + (vect_transform_stmt): Likewise. + * tree-vect-slp.c (vect_get_and_check_slp_defs): Handle reduction. + (vect_build_slp_tree): Fix indentation. Check that there are no loads + from different interleaving chains in same node. + (vect_slp_rearrange_stmts): New function. + (vect_supported_load_permutation_p): Allow load permutations for + reductions. Call vect_slp_rearrange_stmts() to rearrange statements + inside SLP nodes if necessary. + (vect_analyze_slp_instance): Handle reductions. + (vect_analyze_slp): Try to build SLP instances originating from groups + of reductions. + (vect_detect_hybrid_slp_stmts): Skip reduction statements. + (vect_get_constant_vectors): Create initial vectors for reductions + according to reduction code. Add new argument. + (vect_get_slp_defs): Add new argument, pass it to + vect_get_constant_vectors. + (vect_schedule_slp_instance): Remove SLP tree root statements. + +2010-04-19 Jakub Jelinek + + * tree.h (ENUM_IS_SCOPED): Define. + * dwarf2out.c (gen_enumeration_type_die): Add DW_AT_enum_class + for ENUM_IS_SCOPED enums. + +2010-04-18 Eric Botcazou + + * fold-const.c (fold_comparison): Use ssizetype. + * gimple-fold.c (maybe_fold_offset_to_array_ref): Likewise. + * ipa-prop.c (ipa_modify_call_arguments): Use sizetype. + * tree-loop-distribution.c (build_size_arg_loc): Likewise. + * tree-object-size.c (compute_object_sizes): Use size_type_node. + + * tree.h (initialize_sizetypes): Remove parameter. + (build_common_tree_nodes): Remove second parameter. + * stor-layout.c (initialize_sizetypes): Remove parameter. + Always create an unsigned type. + (set_sizetype): Assert that the passed type is unsigned and simplify. + * tree.c (build_common_tree_nodes): Remove second parameter. + Adjust call to initialize_sizetypes. + * c-decl.c (c_init_decl_processing): Remove second argument in call to + build_common_tree_nodes. + +2010-04-18 Matthias Klose + + * gcc.c (main): Search for liblto_plugin.so with mode R_OK. + +2010-04-18 Ira Rosen + + PR tree-optimization/43771 + * tree-vect-slp.c (vect_supported_load_permutation_p): Check that + load permutation doesn't have gaps. + +2010-04-18 Jan Hubicka + + * i386.md (UNSPEC_SSE_PROLOGUE_SAVE_LOW): New. + (sse_prologue_save_insn expander): Use new pattern. + (sse_prologue_save_insn1): New pattern and splitter. + (sse_prologue_save_insn): Update to deal also with 64bit aligned + blocks. + * i386.c (setup_incoming_varargs_64): Do not compute jump + destination here. + (ix86_gimplify_va_arg): Update alignment needed. + (ix86_local_alignment): Do not align all local arrays to 128bit. + +2010-04-17 Jan Hubicka + + * ipa-inline.c (cgraph_early_inlining): Handle flattening too. + +2010-04-17 Richard Earnshaw + + * arm.md (negdi2): Remove redundant code to force values into a + register. + +2010-04-17 Richard Earnshaw + + * arm/bpabi.S: Add EABI alignment attributes to objects. + * arm/bpabi-v6m.S: Likewise. + * arm/crti.asm: Likewise. + * arm/crtn.asm: Likewise. + * arm/lib1funcs.asm: Likewise. + * arm/libunwind.S: Likewise. + 2010-04-17 Richard Earnshaw * arm-protos.h (tune_params): New structure. @@ -51,7 +649,7 @@ * config/i386/i386.md (*jcc_bt): Fix build breakage by adding missing left parenthesis. - + 2010-04-16 Uros Bizjak * config/i386/i386.md (*bt): Macroize insn from *btsi and @@ -83,7 +681,7 @@ * config/h8300/h8300.h (OK_FOR_U): Support 'U' constraint for H8300SX. - * config/h8300/h8300.md (movqi_h8sx, movhi_h8sx, movsi_h8sx, + * config/h8300/h8300.md (movqi_h8sx, movhi_h8sx, movsi_h8sx, cmphi_h8300hs_znvc, cmpsi, addhi3_h8sx) : Emit instructions in #xx:3 and #xx:4 mode. @@ -95,8 +693,7 @@ 2010-04-16 Rainer Orth - * configure.ac: Check for elf_getshdrstrndx or elf_getshstrndx - flavor. + * configure.ac: Check for elf_getshdrstrndx or elf_getshstrndx flavor. * configure: Regenerate. * config.in: Regenerate. * doc/install.texi (Prerequisites): Document that Solaris 2 libelf @@ -127,8 +724,7 @@ 2010-04-16 Diego Novillo - * doc/invoke.texi: Explain how are unrecognized -Wno- warnings - handled. + * doc/invoke.texi: Explain how are unrecognized -Wno- warnings handled. 2010-04-16 Bernd Schmidt @@ -258,8 +854,7 @@ (dump_points_to_solution): Likewise. * tree-dfa.c (dump_variable): Also dump DECL_PT_UID. * tree-inline.c (remap_ssa_name): Copy IPA points-to solution. - (remap_gimple_stmt): Reset call clobber/use information if - necessary. + (remap_gimple_stmt): Reset call clobber/use information if necessary. (copy_decl_to_var): Copy DECL_PT_UID. (copy_result_decl_to_var): Likewise. * tree.c (make_node_stat): Initialize DECL_PT_UID. @@ -327,7 +922,7 @@ PR target/43742 * config/sh/sh.md (doloop_end_split): Remove "+r" constraint - in an input-only operand. + in an input-only operand. 2010-04-15 Anatoly Sokolov @@ -336,7 +931,7 @@ (double_int_negative_p): Convert to static inline function. * double-int.c (double_int_lshift, double_int_lshift): Add new function. (double_int_negative_p): Remove. - * tree.h (lshift_double, rshift_double): + * tree.h (lshift_double, rshift_double): * tree.c (build_low_bits_mask): Clean up, use double_int_* functions. * fold-const.c (fold_convert_const_int_from_real, fold_convert_const_int_from_fixed, div_if_zero_remainder): (Ditto.). @@ -346,7 +941,7 @@ * expmed.c (mask_rtx, lshift_value): (Ditto.). 2010-04-14 Bernd Schmidt - + PR target/21803 * ifcvt.c (cond_exec_process_if_block): Look for identical sequences at the start and end of the then/else blocks, and omit them from the @@ -4178,7 +4773,7 @@ statements ... (vrp_visit_phi_node): ... but only for loop PHI nodes. -2010-02-16 Ira Rosen +2010-02-16 Ira Rosen PR tree-optimization/43074 * tree-vectorizer.h (VECTORIZABLE_CYCLE_DEF): New. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index d96e14963aa..8a9ee03883d 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20100417 +20100423 diff --git a/gcc/Makefile.in b/gcc/Makefile.in index e212225fdeb..3d9aac8376f 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1258,7 +1258,6 @@ OBJS-common = \ lto-symtab.o \ lto-opts.o \ lto-streamer.o \ - lto-wpa-fixup.o \ lto-compress.o \ mcf.o \ mode-switching.o \ @@ -2251,10 +2250,6 @@ lto-opts.o: lto-opts.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \ lto-streamer.o: lto-streamer.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(TREE_H) $(GIMPLE_H) $(BITMAP_H) $(LTO_STREAMER_H) $(FLAGS_H) \ $(TREE_FLOW_H) $(DIAGNOSTIC_H) $(LTO_SYMTAB_H) $(TOPLEV_H) -lto-wpa-fixup.o: lto-wpa-fixup.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ - $(TM_H) $(TOPLEV_H) $(TREE_H) $(EXPR_H) $(FLAGS_H) $(CGRAPH_H) \ - $(FUNCTION_H) $(DIAGNOSTIC_H) $(BITMAP_H) $(TIMEVAR_H) \ - $(TREE_FLOW_H) $(TREE_PASS_H) $(LTO_STREAMER_H) langhooks.o : langhooks.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(TREE_H) $(TOPLEV_H) $(TREE_INLINE_H) $(RTL_H) insn-config.h $(INTEGRATE_H) \ langhooks.h $(TARGET_H) $(LANGHOOKS_DEF_H) $(FLAGS_H) $(GGC_H) $(DIAGNOSTIC_H) \ diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 2a0af0b7bcc..76aa31591c1 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,36 @@ +2010-04-18 Eric Botcazou + + * gcc-interface/misc.c (gnat_init): Remove second argument in call to + build_common_tree_nodes. + +2010-04-18 Ozkan Sezer + + * gsocket.h: Make sure that winsock2.h is included before windows.h. + +2010-04-17 Eric Botcazou + + * gcc-interface/utils2.c (build_unary_op) : Do not + issue warning. + +2010-04-17 Eric Botcazou + + * uintp.h (UI_Lt): Declare. + * gcc-interface/decl.c (gnat_to_gnu_entity) : Do the size + computation in sizetype. + : Use unified handling for all index types. Do not + generate MAX_EXPR-based expressions, only COND_EXPR-based ones. Add + bypass for PATs. + (annotate_value): Change test for negative values. + (validate_size): Apply test for negative values on GNAT nodes. + (set_rm_size): Likewise. + * gcc-interface/misc.c (gnat_init): Set unsigned types for sizetypes. + * gcc-interface/utils.c (rest_of_record_type_compilation): Change test + for negative values. + (max_size) : Do not reassociate a COND_EXPR on the LHS. + (builtin_type_for_size): Adjust definition of signed_size_type_node. + * gcc-interface/utils2.c (compare_arrays): Optimize comparison of + lengths against zero. + 2010-04-17 Eric Botcazou * back-end.adb (Call_Back_End): Pass Standard_Character to gigi. diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index 5d6bc79fd93..f9d88a6a9bb 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -1889,55 +1889,59 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) char field_name[16]; tree gnu_index_base_type = get_unpadded_type (Base_Type (Etype (gnat_index))); - tree gnu_low_field, gnu_high_field, gnu_low, gnu_high, gnu_max; + tree gnu_lb_field, gnu_hb_field, gnu_orig_min, gnu_orig_max; + tree gnu_min, gnu_max, gnu_high; /* Make the FIELD_DECLs for the low and high bounds of this type and then make extractions of these fields from the template. */ sprintf (field_name, "LB%d", index); - gnu_low_field = create_field_decl (get_identifier (field_name), - gnu_index_base_type, - gnu_template_type, 0, - NULL_TREE, NULL_TREE, 0); + gnu_lb_field = create_field_decl (get_identifier (field_name), + gnu_index_base_type, + gnu_template_type, 0, + NULL_TREE, NULL_TREE, 0); Sloc_to_locus (Sloc (gnat_entity), - &DECL_SOURCE_LOCATION (gnu_low_field)); + &DECL_SOURCE_LOCATION (gnu_lb_field)); field_name[0] = 'U'; - gnu_high_field = create_field_decl (get_identifier (field_name), - gnu_index_base_type, - gnu_template_type, 0, - NULL_TREE, NULL_TREE, 0); + gnu_hb_field = create_field_decl (get_identifier (field_name), + gnu_index_base_type, + gnu_template_type, 0, + NULL_TREE, NULL_TREE, 0); Sloc_to_locus (Sloc (gnat_entity), - &DECL_SOURCE_LOCATION (gnu_high_field)); + &DECL_SOURCE_LOCATION (gnu_hb_field)); - gnu_temp_fields[index] = chainon (gnu_low_field, gnu_high_field); + gnu_temp_fields[index] = chainon (gnu_lb_field, gnu_hb_field); /* We can't use build_component_ref here since the template type isn't complete yet. */ - gnu_low = build3 (COMPONENT_REF, gnu_index_base_type, - gnu_template_reference, gnu_low_field, - NULL_TREE); - gnu_high = build3 (COMPONENT_REF, gnu_index_base_type, - gnu_template_reference, gnu_high_field, - NULL_TREE); - TREE_READONLY (gnu_low) = TREE_READONLY (gnu_high) = 1; - - /* Compute the size of this dimension. */ - gnu_max - = build3 (COND_EXPR, gnu_index_base_type, - build2 (GE_EXPR, boolean_type_node, gnu_high, gnu_low), - gnu_high, - build2 (MINUS_EXPR, gnu_index_base_type, - gnu_low, fold_convert (gnu_index_base_type, - integer_one_node))); + gnu_orig_min = build3 (COMPONENT_REF, gnu_index_base_type, + gnu_template_reference, gnu_lb_field, + NULL_TREE); + gnu_orig_max = build3 (COMPONENT_REF, gnu_index_base_type, + gnu_template_reference, gnu_hb_field, + NULL_TREE); + TREE_READONLY (gnu_orig_min) = TREE_READONLY (gnu_orig_max) = 1; + + gnu_min = convert (sizetype, gnu_orig_min); + gnu_max = convert (sizetype, gnu_orig_max); + + /* Compute the size of this dimension. See the E_Array_Subtype + case below for the rationale. */ + gnu_high + = build3 (COND_EXPR, sizetype, + build2 (GE_EXPR, boolean_type_node, + gnu_orig_max, gnu_orig_min), + gnu_max, + size_binop (MINUS_EXPR, gnu_min, size_one_node)); /* Make a range type with the new range in the Ada base type. Then make an index type with the size range in sizetype. */ gnu_index_types[index] - = create_index_type (convert (sizetype, gnu_low), - convert (sizetype, gnu_max), + = create_index_type (gnu_min, gnu_high, create_range_type (gnu_index_base_type, - gnu_low, gnu_high), + gnu_orig_min, + gnu_orig_max), gnat_entity); /* Update the maximum size of the array in elements. */ @@ -2112,15 +2116,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) gnat_base_index = Next_Index (gnat_base_index)) { tree gnu_index_type = get_unpadded_type (Etype (gnat_index)); - const int prec_comp - = compare_tree_int (rm_size (gnu_index_type), - TYPE_PRECISION (sizetype)); - const bool subrange_p = (prec_comp < 0 - && (TYPE_UNSIGNED (gnu_index_type) - || !TYPE_UNSIGNED (sizetype))) - || (prec_comp == 0 - && TYPE_UNSIGNED (gnu_index_type) - == TYPE_UNSIGNED (sizetype)); tree gnu_orig_min = TYPE_MIN_VALUE (gnu_index_type); tree gnu_orig_max = TYPE_MAX_VALUE (gnu_index_type); tree gnu_min = convert (sizetype, gnu_orig_min); @@ -2129,7 +2124,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) = get_unpadded_type (Etype (gnat_base_index)); tree gnu_base_orig_min = TYPE_MIN_VALUE (gnu_base_index_type); tree gnu_base_orig_max = TYPE_MAX_VALUE (gnu_base_index_type); - tree gnu_high, gnu_low; + tree gnu_high; /* See if the base array type is already flat. If it is, we are probably compiling an ACATS test but it will cause the @@ -2145,8 +2140,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) /* Similarly, if one of the values overflows in sizetype and the range is null, use 1..0 for the sizetype bounds. */ - else if (!subrange_p - && TREE_CODE (gnu_min) == INTEGER_CST + else if (TREE_CODE (gnu_min) == INTEGER_CST && TREE_CODE (gnu_max) == INTEGER_CST && (TREE_OVERFLOW (gnu_min) || TREE_OVERFLOW (gnu_max)) && tree_int_cst_lt (gnu_orig_max, gnu_orig_min)) @@ -2159,8 +2153,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) /* If the minimum and maximum values both overflow in sizetype, but the difference in the original type does not overflow in sizetype, ignore the overflow indication. */ - else if (!subrange_p - && TREE_CODE (gnu_min) == INTEGER_CST + else if (TREE_CODE (gnu_min) == INTEGER_CST && TREE_CODE (gnu_max) == INTEGER_CST && TREE_OVERFLOW (gnu_min) && TREE_OVERFLOW (gnu_max) && !TREE_OVERFLOW @@ -2179,57 +2172,49 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) deal with the "superflat" case. There are three ways to do this. If we can prove that the array can never be superflat, we can just use the high bound of the index type. */ - else if (Nkind (gnat_index) == N_Range - && cannot_be_superflat_p (gnat_index)) + else if ((Nkind (gnat_index) == N_Range + && cannot_be_superflat_p (gnat_index)) + /* Packed Array Types are never superflat. */ + || Is_Packed_Array_Type (gnat_entity)) gnu_high = gnu_max; - /* Otherwise, if we can prove that the low bound minus one and - the high bound cannot overflow, we can just use the expression - MAX (hb, lb - 1). Similarly, if we can prove that the high - bound plus one and the low bound cannot overflow, we can use - the high bound as-is and MIN (hb + 1, lb) for the low bound. - Otherwise, we have to fall back to the most general expression - (hb >= lb) ? hb : lb - 1. Note that the comparison must be - done in the original index type, to avoid any overflow during - the conversion. */ - else + /* Otherwise, if the high bound is constant but the low bound is + not, we use the expression (hb >= lb) ? lb : hb + 1 for the + lower bound. Note that the comparison must be done in the + original type to avoid any overflow during the conversion. */ + else if (TREE_CODE (gnu_max) == INTEGER_CST + && TREE_CODE (gnu_min) != INTEGER_CST) { - gnu_high = size_binop (MINUS_EXPR, gnu_min, size_one_node); - gnu_low = size_binop (PLUS_EXPR, gnu_max, size_one_node); - - /* If gnu_high is a constant that has overflowed, the low - bound is the smallest integer so cannot be the maximum. - If gnu_low is a constant that has overflowed, the high - bound is the highest integer so cannot be the minimum. */ - if ((TREE_CODE (gnu_high) == INTEGER_CST - && TREE_OVERFLOW (gnu_high)) - || (TREE_CODE (gnu_low) == INTEGER_CST - && TREE_OVERFLOW (gnu_low))) - gnu_high = gnu_max; - - /* If the index type is a subrange and gnu_high a constant - that hasn't overflowed, we can use the maximum. */ - else if (subrange_p && TREE_CODE (gnu_high) == INTEGER_CST) - gnu_high = size_binop (MAX_EXPR, gnu_max, gnu_high); - - /* If the index type is a subrange and gnu_low a constant - that hasn't overflowed, we can use the minimum. */ - else if (subrange_p && TREE_CODE (gnu_low) == INTEGER_CST) - { - gnu_high = gnu_max; - gnu_min = size_binop (MIN_EXPR, gnu_min, gnu_low); - } - - else - gnu_high - = build_cond_expr (sizetype, - build_binary_op (GE_EXPR, - boolean_type_node, - gnu_orig_max, - gnu_orig_min), - gnu_max, gnu_high); + gnu_high = gnu_max; + gnu_min + = build_cond_expr (sizetype, + build_binary_op (GE_EXPR, + boolean_type_node, + gnu_orig_max, + gnu_orig_min), + gnu_min, + size_binop (PLUS_EXPR, gnu_max, + size_one_node)); } + /* Finally we use (hb >= lb) ? hb : lb - 1 for the upper bound + in all the other cases. Note that, here as well as above, + the condition used in the comparison must be equivalent to + the condition (length != 0). This is relied upon in order + to optimize array comparisons in compare_arrays. */ + else + gnu_high + = build_cond_expr (sizetype, + build_binary_op (GE_EXPR, + boolean_type_node, + gnu_orig_max, + gnu_orig_min), + gnu_max, + size_binop (MINUS_EXPR, gnu_min, + size_one_node)); + + /* Reuse the index type for the range type. Then make an index + type with the size range in sizetype. */ gnu_index_types[index] = create_index_type (gnu_min, gnu_high, gnu_index_type, gnat_entity); @@ -2299,7 +2284,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) && TREE_CODE (TREE_TYPE (gnu_index_type)) != INTEGER_TYPE) || TYPE_BIASED_REPRESENTATION_P (gnu_index_type) - || prec_comp > 0) + || compare_tree_int (rm_size (gnu_index_type), + TYPE_PRECISION (sizetype)) > 0) need_index_type_struct = true; } @@ -7128,9 +7114,11 @@ annotate_value (tree gnu_size) this is in bitsizetype. */ gnu_size = convert (bitsizetype, gnu_size); - /* For a negative value, use NEGATE_EXPR of the opposite. Such values - appear in expressions containing aligning patterns. */ - if (tree_int_cst_sgn (gnu_size) < 0) + /* For a negative value, build NEGATE_EXPR of the opposite. Such values + appear in expressions containing aligning patterns. Note that, since + sizetype is sign-extended but nonetheless unsigned, we don't directly + use tree_int_cst_sgn. */ + if (TREE_INT_CST_HIGH (gnu_size) < 0) { tree op_size = fold_build1 (NEGATE_EXPR, bitsizetype, gnu_size); return annotate_value (build1 (NEGATE_EXPR, bitsizetype, op_size)); @@ -7498,6 +7486,10 @@ validate_size (Uint uint_size, tree gnu_type, Entity_Id gnat_object, if (uint_size == No_Uint) return NULL_TREE; + /* Ignore a negative size since that corresponds to our back-annotation. */ + if (UI_Lt (uint_size, Uint_0)) + return NULL_TREE; + /* Find the node to use for errors. */ if ((Ekind (gnat_object) == E_Component || Ekind (gnat_object) == E_Discriminant) @@ -7522,9 +7514,8 @@ validate_size (Uint uint_size, tree gnu_type, Entity_Id gnat_object, return NULL_TREE; } - /* Ignore a negative size since that corresponds to our back-annotation. - Also ignore a zero size if it is not permitted. */ - if (tree_int_cst_sgn (size) < 0 || (integer_zerop (size) && !zero_ok)) + /* Ignore a zero size if it is not permitted. */ + if (!zero_ok && integer_zerop (size)) return NULL_TREE; /* The size of objects is always a multiple of a byte. */ @@ -7611,6 +7602,10 @@ set_rm_size (Uint uint_size, tree gnu_type, Entity_Id gnat_entity) if (uint_size == No_Uint) return; + /* Ignore a negative size since that corresponds to our back-annotation. */ + if (UI_Lt (uint_size, Uint_0)) + return; + /* Only issue an error if a Value_Size clause was explicitly given. Otherwise, we'd be duplicating an error on the Size clause. */ gnat_attr_node @@ -7627,15 +7622,13 @@ set_rm_size (Uint uint_size, tree gnu_type, Entity_Id gnat_entity) return; } - /* Ignore a negative size since that corresponds to our back-annotation. - Also ignore a zero size unless a Value_Size clause exists, or a size - clause exists, or this is an integer type, in which case the front-end - will have always set it. */ - if (tree_int_cst_sgn (size) < 0 - || (integer_zerop (size) - && No (gnat_attr_node) - && !Has_Size_Clause (gnat_entity) - && !Is_Discrete_Or_Fixed_Point_Type (gnat_entity))) + /* Ignore a zero size unless a Value_Size clause exists, or a size clause + exists, or this is an integer type, in which case the front-end will + have always set it. */ + if (No (gnat_attr_node) + && integer_zerop (size) + && !Has_Size_Clause (gnat_entity) + && !Is_Discrete_Or_Fixed_Point_Type (gnat_entity)) return; old_size = rm_size (gnu_type); diff --git a/gcc/ada/gcc-interface/misc.c b/gcc/ada/gcc-interface/misc.c index f3e7b1b7482..41c61853c70 100644 --- a/gcc/ada/gcc-interface/misc.c +++ b/gcc/ada/gcc-interface/misc.c @@ -6,7 +6,7 @@ * * * C Implementation File * * * - * Copyright (C) 1992-2009, Free Software Foundation, Inc. * + * Copyright (C) 1992-2010, Free Software Foundation, Inc. * * * * GNAT is free software; you can redistribute it and/or modify it under * * terms of the GNU General Public License as published by the Free Soft- * @@ -391,13 +391,16 @@ gnat_init (void) /* Do little here, most of the standard declarations are set up after the front-end has been run. Use the same `char' as C, this doesn't really matter since we'll use the explicit `unsigned char' for Character. */ - build_common_tree_nodes (flag_signed_char, true); - - /* In Ada, we use a signed type for SIZETYPE. Use the signed type - corresponding to the width of Pmode. In most cases when ptr_mode - and Pmode differ, C will use the width of ptr_mode for SIZETYPE. - But we get far better code using the width of Pmode. */ - size_type_node = gnat_type_for_mode (Pmode, 0); + build_common_tree_nodes (flag_signed_char); + + /* In Ada, we use the unsigned type corresponding to the width of Pmode as + SIZETYPE. In most cases when ptr_mode and Pmode differ, C will use the + width of ptr_mode for SIZETYPE, but we get better code using the width + of Pmode. Note that, although we manipulate negative offsets for some + internal constructs and rely on compile time overflow detection in size + computations, using unsigned types for SIZETYPEs is fine since they are + treated specially by the middle-end, in particular sign-extended. */ + size_type_node = gnat_type_for_mode (Pmode, 1); set_sizetype (size_type_node); TYPE_NAME (sizetype) = get_identifier ("size_type"); diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index 668226bd906..7b403a7bab8 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -839,11 +839,13 @@ rest_of_record_type_compilation (tree record_type) align = tree_low_cst (TREE_OPERAND (curpos, 1), 1); /* An offset which is a bitwise AND with a negative power of 2 - means an alignment corresponding to this power of 2. */ + means an alignment corresponding to this power of 2. Note + that, as sizetype is sign-extended but nonetheless unsigned, + we don't directly use tree_int_cst_sgn. */ offset = remove_conversions (offset, true); if (TREE_CODE (offset) == BIT_AND_EXPR && host_integerp (TREE_OPERAND (offset, 1), 0) - && tree_int_cst_sgn (TREE_OPERAND (offset, 1)) < 0) + && TREE_INT_CST_HIGH (TREE_OPERAND (offset, 1)) < 0) { unsigned int pow = - tree_low_cst (TREE_OPERAND (offset, 1), 0); @@ -2175,22 +2177,6 @@ max_size (tree exp, bool max_p) if (code == COMPOUND_EXPR) return max_size (TREE_OPERAND (exp, 1), max_p); - /* Calculate "(A ? B : C) - D" as "A ? B - D : C - D" which - may provide a tighter bound on max_size. */ - if (code == MINUS_EXPR - && TREE_CODE (TREE_OPERAND (exp, 0)) == COND_EXPR) - { - tree lhs = fold_build2 (MINUS_EXPR, type, - TREE_OPERAND (TREE_OPERAND (exp, 0), 1), - TREE_OPERAND (exp, 1)); - tree rhs = fold_build2 (MINUS_EXPR, type, - TREE_OPERAND (TREE_OPERAND (exp, 0), 2), - TREE_OPERAND (exp, 1)); - return fold_build2 (max_p ? MAX_EXPR : MIN_EXPR, type, - max_size (lhs, max_p), - max_size (rhs, max_p)); - } - { tree lhs = max_size (TREE_OPERAND (exp, 0), max_p); tree rhs = max_size (TREE_OPERAND (exp, 1), @@ -4707,7 +4693,7 @@ builtin_type_for_size (int size, bool unsignedp) static void install_builtin_elementary_types (void) { - signed_size_type_node = size_type_node; + signed_size_type_node = gnat_signed_type (size_type_node); pid_type_node = integer_type_node; void_list_node = build_void_list_node (); diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c index be7044bddfa..9b00c0dfced 100644 --- a/gcc/ada/gcc-interface/utils2.c +++ b/gcc/ada/gcc-interface/utils2.c @@ -351,14 +351,26 @@ compare_arrays (tree result_type, tree a1, tree a2) if (EXPR_P (comparison)) SET_EXPR_LOCATION (comparison, input_location); - this_a1_is_null = build_binary_op (EQ_EXPR, result_type, length1, - size_zero_node); - if (EXPR_P (this_a1_is_null)) + /* If the length expression is of the form (cond ? val : 0), assume + that cond is equivalent to (length != 0). That's guaranteed by + construction of the array types in gnat_to_gnu_entity. */ + if (TREE_CODE (length1) == COND_EXPR + && integer_zerop (TREE_OPERAND (length1, 2))) + this_a1_is_null = invert_truthvalue (TREE_OPERAND (length1, 0)); + else + this_a1_is_null = build_binary_op (EQ_EXPR, result_type, length1, + size_zero_node); + if (EXPR_P (this_a1_is_null)) SET_EXPR_LOCATION (this_a1_is_null, input_location); - this_a2_is_null = build_binary_op (EQ_EXPR, result_type, length2, - size_zero_node); - if (EXPR_P (this_a2_is_null)) + /* Likewise for the second array. */ + if (TREE_CODE (length2) == COND_EXPR + && integer_zerop (TREE_OPERAND (length2, 2))) + this_a2_is_null = invert_truthvalue (TREE_OPERAND (length2, 0)); + else + this_a2_is_null = build_binary_op (EQ_EXPR, result_type, length2, + size_zero_node); + if (EXPR_P (this_a2_is_null)) SET_EXPR_LOCATION (this_a2_is_null, input_location); } @@ -1068,9 +1080,8 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) case ARRAY_RANGE_REF: case COMPONENT_REF: case BIT_FIELD_REF: - /* If this is for 'Address, find the address of the prefix and - add the offset to the field. Otherwise, do this the normal - way. */ + /* If this is for 'Address, find the address of the prefix and add + the offset to the field. Otherwise, do this the normal way. */ if (op_code == ATTR_ADDR_EXPR) { HOST_WIDE_INT bitsize; @@ -1097,11 +1108,6 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) if (!offset) offset = size_zero_node; - if (bitpos % BITS_PER_UNIT != 0) - post_error - ("taking address of object not aligned on storage unit?", - error_gnat_node); - offset = size_binop (PLUS_EXPR, offset, size_int (bitpos / BITS_PER_UNIT)); diff --git a/gcc/ada/gsocket.h b/gcc/ada/gsocket.h index ca016c921c0..a8e6faa2467 100644 --- a/gcc/ada/gsocket.h +++ b/gcc/ada/gsocket.h @@ -71,7 +71,6 @@ #elif defined (WINNT) #define FD_SETSIZE 1024 -#include #ifdef __MINGW32__ #include @@ -160,6 +159,8 @@ #endif +#include + #elif defined(VMS) #define FD_SETSIZE 4096 #ifndef IN_RTS diff --git a/gcc/ada/uintp.h b/gcc/ada/uintp.h index de70e115f43..630fcd18e06 100644 --- a/gcc/ada/uintp.h +++ b/gcc/ada/uintp.h @@ -75,6 +75,10 @@ typedef struct {const int *Array; Vector_Template *Bounds; } #define Vector_To_Uint uintp__vector_to_uint extern Uint Vector_To_Uint (Int_Vector, Boolean); +/* Compare integer values for less than. */ +#define UI_Lt uintp__ui_lt +extern Boolean UI_Lt (Uint, Uint); + /* Universal integers are represented by the Uint type which is an index into the Uints_Ptr table containing Uint_Entry values. A Uint_Entry contains an index and length for getting the "digits" of the universal integer from the diff --git a/gcc/builtins.c b/gcc/builtins.c index dbab4847af0..997c13a5505 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -5279,7 +5279,6 @@ expand_builtin_signbit (tree exp, rtx target) { const struct real_format *fmt; enum machine_mode fmode, imode, rmode; - HOST_WIDE_INT hi, lo; tree arg; int word, bitpos; enum insn_code icode; @@ -5355,21 +5354,12 @@ expand_builtin_signbit (tree exp, rtx target) if (bitpos < GET_MODE_BITSIZE (rmode)) { - if (bitpos < HOST_BITS_PER_WIDE_INT) - { - hi = 0; - lo = (HOST_WIDE_INT) 1 << bitpos; - } - else - { - hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT); - lo = 0; - } + double_int mask = double_int_setbit (double_int_zero, bitpos); if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode)) temp = gen_lowpart (rmode, temp); temp = expand_binop (rmode, and_optab, temp, - immed_double_const (lo, hi, rmode), + immed_double_int_const (mask, rmode), NULL_RTX, 1, OPTAB_LIB_WIDEN); } else @@ -7052,6 +7042,77 @@ fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl) return NULL_TREE; } +/* Build a complex (inf +- 0i) for the result of cproj. TYPE is the + complex tree type of the result. If NEG is true, the imaginary + zero is negative. */ + +static tree +build_complex_cproj (tree type, bool neg) +{ + REAL_VALUE_TYPE rinf, rzero = dconst0; + + real_inf (&rinf); + rzero.sign = neg; + return build_complex (type, build_real (TREE_TYPE (type), rinf), + build_real (TREE_TYPE (type), rzero)); +} + +/* Fold call to builtin cproj, cprojf or cprojl with argument ARG. TYPE is the + return type. Return NULL_TREE if no simplification can be made. */ + +static tree +fold_builtin_cproj (location_t loc, tree arg, tree type) +{ + if (!validate_arg (arg, COMPLEX_TYPE) + || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE) + return NULL_TREE; + + /* If there are no infinities, return arg. */ + if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type)))) + return non_lvalue_loc (loc, arg); + + /* Calculate the result when the argument is a constant. */ + if (TREE_CODE (arg) == COMPLEX_CST) + { + const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg)); + const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg)); + + if (real_isinf (real) || real_isinf (imag)) + return build_complex_cproj (type, imag->sign); + else + return arg; + } + else if (TREE_CODE (arg) == COMPLEX_EXPR) + { + tree real = TREE_OPERAND (arg, 0); + tree imag = TREE_OPERAND (arg, 1); + + STRIP_NOPS (real); + STRIP_NOPS (imag); + + /* If the real part is inf and the imag part is known to be + nonnegative, return (inf + 0i). Remember side-effects are + possible in the imag part. */ + if (TREE_CODE (real) == REAL_CST + && real_isinf (TREE_REAL_CST_PTR (real)) + && tree_expr_nonnegative_p (imag)) + return omit_one_operand_loc (loc, type, + build_complex_cproj (type, false), + arg); + + /* If the imag part is inf, return (inf+I*copysign(0,imag)). + Remember side-effects are possible in the real part. */ + if (TREE_CODE (imag) == REAL_CST + && real_isinf (TREE_REAL_CST_PTR (imag))) + return + omit_one_operand_loc (loc, type, + build_complex_cproj (type, TREE_REAL_CST_PTR + (imag)->sign), arg); + } + + return NULL_TREE; +} + /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG. Return NULL_TREE if no simplification can be made. */ @@ -9809,6 +9870,9 @@ fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore) CASE_FLT_FN (BUILT_IN_CCOSH): return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true); + CASE_FLT_FN (BUILT_IN_CPROJ): + return fold_builtin_cproj(loc, arg0, type); + CASE_FLT_FN (BUILT_IN_CSIN): if (validate_arg (arg0, COMPLEX_TYPE) && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE) diff --git a/gcc/builtins.def b/gcc/builtins.def index 09177a9001a..4e4eb3edc03 100644 --- a/gcc/builtins.def +++ b/gcc/builtins.def @@ -479,9 +479,9 @@ DEF_C99_BUILTIN (BUILT_IN_CONJL, "conjl", BT_FN_COMPLEX_LONGDOUBLE_COMPLE DEF_C99_BUILTIN (BUILT_IN_CPOW, "cpow", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) DEF_C99_BUILTIN (BUILT_IN_CPOWF, "cpowf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) DEF_C99_BUILTIN (BUILT_IN_CPOWL, "cpowl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) -DEF_C99_BUILTIN (BUILT_IN_CPROJ, "cproj", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING) -DEF_C99_BUILTIN (BUILT_IN_CPROJF, "cprojf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING) -DEF_C99_BUILTIN (BUILT_IN_CPROJL, "cprojl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING) +DEF_C99_BUILTIN (BUILT_IN_CPROJ, "cproj", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LIST) +DEF_C99_BUILTIN (BUILT_IN_CPROJF, "cprojf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LIST) +DEF_C99_BUILTIN (BUILT_IN_CPROJL, "cprojl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LIST) DEF_C99_BUILTIN (BUILT_IN_CREAL, "creal", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LIST) DEF_C99_BUILTIN (BUILT_IN_CREALF, "crealf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LIST) DEF_C99_BUILTIN (BUILT_IN_CREALL, "creall", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LIST) diff --git a/gcc/c-decl.c b/gcc/c-decl.c index 1aa924fd873..b34ea6038f8 100644 --- a/gcc/c-decl.c +++ b/gcc/c-decl.c @@ -3471,7 +3471,7 @@ c_init_decl_processing (void) using preprocessed headers. */ input_location = BUILTINS_LOCATION; - build_common_tree_nodes (flag_signed_char, false); + build_common_tree_nodes (flag_signed_char); c_common_nodes_and_builtins (); diff --git a/gcc/c-parser.c b/gcc/c-parser.c index 27f0b819880..a8feb27b883 100644 --- a/gcc/c-parser.c +++ b/gcc/c-parser.c @@ -906,8 +906,9 @@ static tree c_parser_attributes (c_parser *); static struct c_type_name *c_parser_type_name (c_parser *); static struct c_expr c_parser_initializer (c_parser *); static struct c_expr c_parser_braced_init (c_parser *, tree, bool); -static void c_parser_initelt (c_parser *); -static void c_parser_initval (c_parser *, struct c_expr *); +static void c_parser_initelt (c_parser *, struct obstack *); +static void c_parser_initval (c_parser *, struct c_expr *, + struct obstack *); static tree c_parser_compound_statement (c_parser *); static void c_parser_compound_statement_nostart (c_parser *); static void c_parser_label (c_parser *); @@ -3088,11 +3089,14 @@ c_parser_initializer (c_parser *parser) static struct c_expr c_parser_braced_init (c_parser *parser, tree type, bool nested_p) { + struct c_expr ret; + struct obstack braced_init_obstack; location_t brace_loc = c_parser_peek_token (parser)->location; + gcc_obstack_init (&braced_init_obstack); gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE)); c_parser_consume_token (parser); if (nested_p) - push_init_level (0); + push_init_level (0, &braced_init_obstack); else really_start_incremental_init (type); if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) @@ -3105,7 +3109,7 @@ c_parser_braced_init (c_parser *parser, tree type, bool nested_p) comma. */ while (true) { - c_parser_initelt (parser); + c_parser_initelt (parser, &braced_init_obstack); if (parser->error) break; if (c_parser_next_token_is (parser, CPP_COMMA)) @@ -3118,22 +3122,24 @@ c_parser_braced_init (c_parser *parser, tree type, bool nested_p) } if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE)) { - struct c_expr ret; ret.value = error_mark_node; ret.original_code = ERROR_MARK; ret.original_type = NULL; c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>"); - pop_init_level (0); + pop_init_level (0, &braced_init_obstack); + obstack_free (&braced_init_obstack, NULL); return ret; } c_parser_consume_token (parser); - return pop_init_level (0); + ret = pop_init_level (0, &braced_init_obstack); + obstack_free (&braced_init_obstack, NULL); + return ret; } /* Parse a nested initializer, including designators. */ static void -c_parser_initelt (c_parser *parser) +c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack) { /* Parse any designator or designator list. A single array designator may have the subsequent "=" omitted in GNU C, but a @@ -3142,7 +3148,8 @@ c_parser_initelt (c_parser *parser) && c_parser_peek_2nd_token (parser)->type == CPP_COLON) { /* Old-style structure member designator. */ - set_init_label (c_parser_peek_token (parser)->value); + set_init_label (c_parser_peek_token (parser)->value, + braced_init_obstack); /* Use the colon as the error location. */ pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_pedantic, "obsolete use of designated initializer with %<:%>"); @@ -3170,7 +3177,8 @@ c_parser_initelt (c_parser *parser) c_parser_consume_token (parser); if (c_parser_next_token_is (parser, CPP_NAME)) { - set_init_label (c_parser_peek_token (parser)->value); + set_init_label (c_parser_peek_token (parser)->value, + braced_init_obstack); c_parser_consume_token (parser); } else @@ -3181,7 +3189,7 @@ c_parser_initelt (c_parser *parser) init.original_type = NULL; c_parser_error (parser, "expected identifier"); c_parser_skip_until_found (parser, CPP_COMMA, NULL); - process_init_element (init, false); + process_init_element (init, false, braced_init_obstack); return; } } @@ -3262,7 +3270,7 @@ c_parser_initelt (c_parser *parser) /* Now parse and process the remainder of the initializer, starting with this message expression as a primary-expression. */ - c_parser_initval (parser, &mexpr); + c_parser_initval (parser, &mexpr, braced_init_obstack); return; } c_parser_consume_token (parser); @@ -3281,7 +3289,7 @@ c_parser_initelt (c_parser *parser) if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE)) { c_parser_consume_token (parser); - set_init_index (first, second); + set_init_index (first, second, braced_init_obstack); if (second) pedwarn (ellipsis_loc, OPT_pedantic, "ISO C forbids specifying range of elements to initialize"); @@ -3313,13 +3321,13 @@ c_parser_initelt (c_parser *parser) init.original_type = NULL; c_parser_error (parser, "expected %<=%>"); c_parser_skip_until_found (parser, CPP_COMMA, NULL); - process_init_element (init, false); + process_init_element (init, false, braced_init_obstack); return; } } } } - c_parser_initval (parser, NULL); + c_parser_initval (parser, NULL, braced_init_obstack); } /* Parse a nested initializer; as c_parser_initializer but parses @@ -3329,7 +3337,8 @@ c_parser_initelt (c_parser *parser) initializer. */ static void -c_parser_initval (c_parser *parser, struct c_expr *after) +c_parser_initval (c_parser *parser, struct c_expr *after, + struct obstack * braced_init_obstack) { struct c_expr init; gcc_assert (!after || c_dialect_objc ()); @@ -3344,7 +3353,7 @@ c_parser_initval (c_parser *parser, struct c_expr *after) && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR) init = default_function_array_read_conversion (loc, init); } - process_init_element (init, false); + process_init_element (init, false, braced_init_obstack); } /* Parse a compound statement (possibly a function body) (C90 6.6.2, diff --git a/gcc/c-tree.h b/gcc/c-tree.h index 3681ed7dfec..681fe9b4ffe 100644 --- a/gcc/c-tree.h +++ b/gcc/c-tree.h @@ -539,11 +539,11 @@ extern void maybe_warn_string_init (tree, struct c_expr); extern void start_init (tree, tree, int); extern void finish_init (void); extern void really_start_incremental_init (tree); -extern void push_init_level (int); -extern struct c_expr pop_init_level (int); -extern void set_init_index (tree, tree); -extern void set_init_label (tree); -extern void process_init_element (struct c_expr, bool); +extern void push_init_level (int, struct obstack *); +extern struct c_expr pop_init_level (int, struct obstack *); +extern void set_init_index (tree, tree, struct obstack *); +extern void set_init_label (tree, struct obstack *); +extern void process_init_element (struct c_expr, bool, struct obstack *); extern tree build_compound_literal (location_t, tree, tree, bool); extern void check_compound_literal_type (location_t, struct c_type_name *); extern tree c_start_case (location_t, location_t, tree); diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index 9122c6894a1..4baa8b4786a 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -97,14 +97,15 @@ static int spelling_length (void); static char *print_spelling (char *); static void warning_init (int, const char *); static tree digest_init (location_t, tree, tree, tree, bool, bool, int); -static void output_init_element (tree, tree, bool, tree, tree, int, bool); -static void output_pending_init_elements (int); -static int set_designator (int); -static void push_range_stack (tree); -static void add_pending_init (tree, tree, tree, bool); -static void set_nonincremental_init (void); -static void set_nonincremental_init_from_string (tree); -static tree find_init_member (tree); +static void output_init_element (tree, tree, bool, tree, tree, int, bool, + struct obstack *); +static void output_pending_init_elements (int, struct obstack *); +static int set_designator (int, struct obstack *); +static void push_range_stack (tree, struct obstack *); +static void add_pending_init (tree, tree, tree, bool, struct obstack *); +static void set_nonincremental_init (struct obstack *); +static void set_nonincremental_init_from_string (tree, struct obstack *); +static tree find_init_member (tree, struct obstack *); static void readonly_error (tree, enum lvalue_use); static void readonly_warning (tree, enum lvalue_use); static int lvalue_or_else (const_tree, enum lvalue_use); @@ -6433,7 +6434,7 @@ really_start_incremental_init (tree type) IMPLICIT is 1 (or 2 if the push is because of designator list). */ void -push_init_level (int implicit) +push_init_level (int implicit, struct obstack * braced_init_obstack) { struct constructor_stack *p; tree value = NULL_TREE; @@ -6451,12 +6452,14 @@ push_init_level (int implicit) if ((TREE_CODE (constructor_type) == RECORD_TYPE || TREE_CODE (constructor_type) == UNION_TYPE) && constructor_fields == 0) - process_init_element (pop_init_level (1), true); + process_init_element (pop_init_level (1, braced_init_obstack), + true, braced_init_obstack); else if (TREE_CODE (constructor_type) == ARRAY_TYPE && constructor_max_index && tree_int_cst_lt (constructor_max_index, constructor_index)) - process_init_element (pop_init_level (1), true); + process_init_element (pop_init_level (1, braced_init_obstack), + true, braced_init_obstack); else break; } @@ -6469,9 +6472,9 @@ push_init_level (int implicit) if ((TREE_CODE (constructor_type) == RECORD_TYPE || TREE_CODE (constructor_type) == UNION_TYPE) && constructor_fields) - value = find_init_member (constructor_fields); + value = find_init_member (constructor_fields, braced_init_obstack); else if (TREE_CODE (constructor_type) == ARRAY_TYPE) - value = find_init_member (constructor_index); + value = find_init_member (constructor_index, braced_init_obstack); } p = XNEW (struct constructor_stack); @@ -6557,7 +6560,7 @@ push_init_level (int implicit) if (!VEC_empty (constructor_elt, constructor_elements) && (TREE_CODE (constructor_type) == RECORD_TYPE || TREE_CODE (constructor_type) == ARRAY_TYPE)) - set_nonincremental_init (); + set_nonincremental_init (braced_init_obstack); } if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) @@ -6618,7 +6621,7 @@ push_init_level (int implicit) /* We need to split the char/wchar array into individual characters, so that we don't have to special case it everywhere. */ - set_nonincremental_init_from_string (value); + set_nonincremental_init_from_string (value, braced_init_obstack); } } else @@ -6642,7 +6645,7 @@ push_init_level (int implicit) Otherwise, return a CONSTRUCTOR expression as the value. */ struct c_expr -pop_init_level (int implicit) +pop_init_level (int implicit, struct obstack * braced_init_obstack) { struct constructor_stack *p; struct c_expr ret; @@ -6655,14 +6658,16 @@ pop_init_level (int implicit) /* When we come to an explicit close brace, pop any inner levels that didn't have explicit braces. */ while (constructor_stack->implicit) - process_init_element (pop_init_level (1), true); - + { + process_init_element (pop_init_level (1, braced_init_obstack), + true, braced_init_obstack); + } gcc_assert (!constructor_range_stack); } /* Now output all pending elements. */ constructor_incremental = 1; - output_pending_init_elements (1); + output_pending_init_elements (1, braced_init_obstack); p = constructor_stack; @@ -6803,7 +6808,7 @@ pop_init_level (int implicit) ARRAY argument is nonzero for array ranges. Returns zero for success. */ static int -set_designator (int array) +set_designator (int array, struct obstack * braced_init_obstack) { tree subtype; enum tree_code subcode; @@ -6825,7 +6830,10 @@ set_designator (int array) /* Designator list starts at the level of closest explicit braces. */ while (constructor_stack->implicit) - process_init_element (pop_init_level (1), true); + { + process_init_element (pop_init_level (1, braced_init_obstack), + true, braced_init_obstack); + } constructor_designated = 1; return 0; } @@ -6858,7 +6866,7 @@ set_designator (int array) } constructor_designated = 1; - push_init_level (2); + push_init_level (2, braced_init_obstack); return 0; } @@ -6867,11 +6875,13 @@ set_designator (int array) NULL_TREE if there is no range designator at this level. */ static void -push_range_stack (tree range_end) +push_range_stack (tree range_end, struct obstack * braced_init_obstack) { struct constructor_range_stack *p; - p = GGC_NEW (struct constructor_range_stack); + p = (struct constructor_range_stack *) + obstack_alloc (braced_init_obstack, + sizeof (struct constructor_range_stack)); p->prev = constructor_range_stack; p->next = 0; p->fields = constructor_fields; @@ -6889,9 +6899,10 @@ push_range_stack (tree range_end) of indices, running from FIRST through LAST. */ void -set_init_index (tree first, tree last) +set_init_index (tree first, tree last, + struct obstack * braced_init_obstack) { - if (set_designator (1)) + if (set_designator (1, braced_init_obstack)) return; designator_erroneous = 1; @@ -6963,18 +6974,18 @@ set_init_index (tree first, tree last) designator_depth++; designator_erroneous = 0; if (constructor_range_stack || last) - push_range_stack (last); + push_range_stack (last, braced_init_obstack); } } /* Within a struct initializer, specify the next field to be initialized. */ void -set_init_label (tree fieldname) +set_init_label (tree fieldname, struct obstack * braced_init_obstack) { tree tail; - if (set_designator (0)) + if (set_designator (0, braced_init_obstack)) return; designator_erroneous = 1; @@ -7001,7 +7012,7 @@ set_init_label (tree fieldname) designator_depth++; designator_erroneous = 0; if (constructor_range_stack) - push_range_stack (NULL_TREE); + push_range_stack (NULL_TREE, braced_init_obstack); } } @@ -7016,7 +7027,8 @@ set_init_label (tree fieldname) existing initializer. */ static void -add_pending_init (tree purpose, tree value, tree origtype, bool implicit) +add_pending_init (tree purpose, tree value, tree origtype, bool implicit, + struct obstack * braced_init_obstack) { struct init_node *p, **q, *r; @@ -7075,7 +7087,8 @@ add_pending_init (tree purpose, tree value, tree origtype, bool implicit) } } - r = GGC_NEW (struct init_node); + r = (struct init_node *) obstack_alloc (braced_init_obstack, + sizeof (struct init_node)); r->purpose = purpose; r->value = value; r->origtype = origtype; @@ -7244,7 +7257,7 @@ add_pending_init (tree purpose, tree value, tree origtype, bool implicit) /* Build AVL tree from a sorted chain. */ static void -set_nonincremental_init (void) +set_nonincremental_init (struct obstack * braced_init_obstack) { unsigned HOST_WIDE_INT ix; tree index, value; @@ -7254,7 +7267,10 @@ set_nonincremental_init (void) return; FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value) - add_pending_init (index, value, NULL_TREE, false); + { + add_pending_init (index, value, NULL_TREE, false, + braced_init_obstack); + } constructor_elements = 0; if (TREE_CODE (constructor_type) == RECORD_TYPE) { @@ -7281,7 +7297,8 @@ set_nonincremental_init (void) /* Build AVL tree from a string constant. */ static void -set_nonincremental_init_from_string (tree str) +set_nonincremental_init_from_string (tree str, + struct obstack * braced_init_obstack) { tree value, purpose, type; HOST_WIDE_INT val[2]; @@ -7344,7 +7361,8 @@ set_nonincremental_init_from_string (tree str) } value = build_int_cst_wide (type, val[1], val[0]); - add_pending_init (purpose, value, NULL_TREE, false); + add_pending_init (purpose, value, NULL_TREE, false, + braced_init_obstack); } constructor_incremental = 0; @@ -7354,7 +7372,7 @@ set_nonincremental_init_from_string (tree str) not initialized yet. */ static tree -find_init_member (tree field) +find_init_member (tree field, struct obstack * braced_init_obstack) { struct init_node *p; @@ -7362,7 +7380,7 @@ find_init_member (tree field) { if (constructor_incremental && tree_int_cst_lt (field, constructor_unfilled_index)) - set_nonincremental_init (); + set_nonincremental_init (braced_init_obstack); p = constructor_pending_elts; while (p) @@ -7383,7 +7401,7 @@ find_init_member (tree field) && (!constructor_unfilled_fields || tree_int_cst_lt (bitpos, bit_position (constructor_unfilled_fields)))) - set_nonincremental_init (); + set_nonincremental_init (braced_init_obstack); p = constructor_pending_elts; while (p) @@ -7427,7 +7445,8 @@ find_init_member (tree field) static void output_init_element (tree value, tree origtype, bool strict_string, tree type, - tree field, int pending, bool implicit) + tree field, int pending, bool implicit, + struct obstack * braced_init_obstack) { tree semantic_type = NULL_TREE; constructor_elt *celt; @@ -7544,9 +7563,10 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type, { if (constructor_incremental && tree_int_cst_lt (field, constructor_unfilled_index)) - set_nonincremental_init (); + set_nonincremental_init (braced_init_obstack); - add_pending_init (field, value, origtype, implicit); + add_pending_init (field, value, origtype, implicit, + braced_init_obstack); return; } else if (TREE_CODE (constructor_type) == RECORD_TYPE @@ -7559,7 +7579,7 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type, if (constructor_incremental) { if (!constructor_unfilled_fields) - set_nonincremental_init (); + set_nonincremental_init (braced_init_obstack); else { tree bitpos, unfillpos; @@ -7568,11 +7588,12 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type, unfillpos = bit_position (constructor_unfilled_fields); if (tree_int_cst_lt (bitpos, unfillpos)) - set_nonincremental_init (); + set_nonincremental_init (braced_init_obstack); } } - add_pending_init (field, value, origtype, implicit); + add_pending_init (field, value, origtype, implicit, + braced_init_obstack); return; } else if (TREE_CODE (constructor_type) == UNION_TYPE @@ -7621,7 +7642,7 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type, /* Now output any pending elements which have become next. */ if (pending) - output_pending_init_elements (0); + output_pending_init_elements (0, braced_init_obstack); } /* Output any pending elements which have become next. @@ -7634,9 +7655,8 @@ output_init_element (tree value, tree origtype, bool strict_string, tree type, If ALL is 1, we output space as necessary so that we can output all the pending elements. */ - static void -output_pending_init_elements (int all) +output_pending_init_elements (int all, struct obstack * braced_init_obstack) { struct init_node *elt = constructor_pending_elts; tree next; @@ -7657,7 +7677,8 @@ output_pending_init_elements (int all) constructor_unfilled_index)) output_init_element (elt->value, elt->origtype, true, TREE_TYPE (constructor_type), - constructor_unfilled_index, 0, false); + constructor_unfilled_index, 0, false, + braced_init_obstack); else if (tree_int_cst_lt (constructor_unfilled_index, elt->purpose)) { @@ -7711,7 +7732,8 @@ output_pending_init_elements (int all) constructor_unfilled_fields = elt->purpose; output_init_element (elt->value, elt->origtype, true, TREE_TYPE (elt->purpose), - elt->purpose, 0, false); + elt->purpose, 0, false, + braced_init_obstack); } else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) { @@ -7782,7 +7804,8 @@ output_pending_init_elements (int all) existing initializer. */ void -process_init_element (struct c_expr value, bool implicit) +process_init_element (struct c_expr value, bool implicit, + struct obstack * braced_init_obstack) { tree orig_value = value.value; int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST; @@ -7823,13 +7846,15 @@ process_init_element (struct c_expr value, bool implicit) if ((TREE_CODE (constructor_type) == RECORD_TYPE || TREE_CODE (constructor_type) == UNION_TYPE) && constructor_fields == 0) - process_init_element (pop_init_level (1), true); + process_init_element (pop_init_level (1, braced_init_obstack), + true, braced_init_obstack); else if ((TREE_CODE (constructor_type) == ARRAY_TYPE || TREE_CODE (constructor_type) == VECTOR_TYPE) && (constructor_max_index == 0 || tree_int_cst_lt (constructor_max_index, constructor_index))) - process_init_element (pop_init_level (1), true); + process_init_element (pop_init_level (1, braced_init_obstack), + true, braced_init_obstack); else break; } @@ -7899,7 +7924,7 @@ process_init_element (struct c_expr value, bool implicit) && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE)) { - push_init_level (1); + push_init_level (1, braced_init_obstack); continue; } @@ -7908,7 +7933,8 @@ process_init_element (struct c_expr value, bool implicit) push_member_name (constructor_fields); output_init_element (value.value, value.original_type, strict_string, fieldtype, - constructor_fields, 1, implicit); + constructor_fields, 1, implicit, + braced_init_obstack); RESTORE_SPELLING_DEPTH (constructor_depth); } else @@ -7990,7 +8016,7 @@ process_init_element (struct c_expr value, bool implicit) && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE)) { - push_init_level (1); + push_init_level (1, braced_init_obstack); continue; } @@ -7999,7 +8025,8 @@ process_init_element (struct c_expr value, bool implicit) push_member_name (constructor_fields); output_init_element (value.value, value.original_type, strict_string, fieldtype, - constructor_fields, 1, implicit); + constructor_fields, 1, implicit, + braced_init_obstack); RESTORE_SPELLING_DEPTH (constructor_depth); } else @@ -8031,7 +8058,7 @@ process_init_element (struct c_expr value, bool implicit) && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE)) { - push_init_level (1); + push_init_level (1, braced_init_obstack); continue; } @@ -8050,7 +8077,8 @@ process_init_element (struct c_expr value, bool implicit) push_array_bounds (tree_low_cst (constructor_index, 1)); output_init_element (value.value, value.original_type, strict_string, elttype, - constructor_index, 1, implicit); + constructor_index, 1, implicit, + braced_init_obstack); RESTORE_SPELLING_DEPTH (constructor_depth); } @@ -8084,7 +8112,8 @@ process_init_element (struct c_expr value, bool implicit) elttype = TYPE_MAIN_VARIANT (constructor_type); output_init_element (value.value, value.original_type, strict_string, elttype, - constructor_index, 1, implicit); + constructor_index, 1, implicit, + braced_init_obstack); } constructor_index @@ -8112,7 +8141,8 @@ process_init_element (struct c_expr value, bool implicit) if (value.value) output_init_element (value.value, value.original_type, strict_string, constructor_type, - NULL_TREE, 1, implicit); + NULL_TREE, 1, implicit, + braced_init_obstack); constructor_fields = 0; } @@ -8128,14 +8158,17 @@ process_init_element (struct c_expr value, bool implicit) while (constructor_stack != range_stack->stack) { gcc_assert (constructor_stack->implicit); - process_init_element (pop_init_level (1), true); + process_init_element (pop_init_level (1, + braced_init_obstack), + true, braced_init_obstack); } for (p = range_stack; !p->range_end || tree_int_cst_equal (p->index, p->range_end); p = p->prev) { gcc_assert (constructor_stack->implicit); - process_init_element (pop_init_level (1), true); + process_init_element (pop_init_level (1, braced_init_obstack), + true, braced_init_obstack); } p->index = size_binop_loc (input_location, @@ -8155,7 +8188,7 @@ process_init_element (struct c_expr value, bool implicit) p = p->next; if (!p) break; - push_init_level (2); + push_init_level (2, braced_init_obstack); p->stack = constructor_stack; if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) p->index = p->range_start; diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index 48173d9b992..319b1832295 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -2616,6 +2616,22 @@ expand_debug_expr (tree exp) return gen_rtx_FIX (mode, op0); case POINTER_PLUS_EXPR: + /* For the rare target where pointers are not the same size as + size_t, we need to check for mis-matched modes and correct + the addend. */ + if (op0 && op1 + && GET_MODE (op0) != VOIDmode && GET_MODE (op1) != VOIDmode + && GET_MODE (op0) != GET_MODE (op1)) + { + if (GET_MODE_BITSIZE (GET_MODE (op0)) < GET_MODE_BITSIZE (GET_MODE (op1))) + op1 = gen_rtx_TRUNCATE (GET_MODE (op0), op1); + else + /* We always sign-extend, regardless of the signedness of + the operand, because the operand is always unsigned + here even if the original C expression is signed. */ + op1 = gen_rtx_SIGN_EXTEND (GET_MODE (op0), op1); + } + /* Fall through. */ case PLUS_EXPR: return gen_rtx_PLUS (mode, op0, op1); @@ -3007,14 +3023,15 @@ expand_debug_expr (tree exp) if (SCALAR_INT_MODE_P (GET_MODE (op0)) && SCALAR_INT_MODE_P (mode)) { + enum machine_mode inner_mode = GET_MODE (op0); if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)))) - op0 = gen_rtx_ZERO_EXTEND (mode, op0); + op0 = simplify_gen_unary (ZERO_EXTEND, mode, op0, inner_mode); else - op0 = gen_rtx_SIGN_EXTEND (mode, op0); + op0 = simplify_gen_unary (SIGN_EXTEND, mode, op0, inner_mode); if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)))) - op1 = gen_rtx_ZERO_EXTEND (mode, op1); + op1 = simplify_gen_unary (ZERO_EXTEND, mode, op1, inner_mode); else - op1 = gen_rtx_SIGN_EXTEND (mode, op1); + op1 = simplify_gen_unary (SIGN_EXTEND, mode, op1, inner_mode); return gen_rtx_MULT (mode, op0, op1); } return NULL; diff --git a/gcc/cgraph.c b/gcc/cgraph.c index c698d9a5502..c5e0f3d940c 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -1467,7 +1467,8 @@ cgraph_remove_node (struct cgraph_node *node) struct cgraph_node *n = (struct cgraph_node *) *slot; if (!n->clones && !n->clone_of && !n->global.inlined_to && (cgraph_global_info_ready - && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl)))) + && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl) + || n->in_other_partition))) kill_body = true; } if (assembler_name_hash) @@ -1628,6 +1629,8 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node) fprintf (f, "%s/%i(%i)", cgraph_node_name (node), node->uid, node->pid); dump_addr (f, " @", (void *)node); + if (DECL_ASSEMBLER_NAME_SET_P (node->decl)) + fprintf (f, " (asm: %s)", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl))); if (node->global.inlined_to) fprintf (f, " (inline copy in %s/%i)", cgraph_node_name (node->global.inlined_to), @@ -1639,6 +1642,10 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node) if (cgraph_function_flags_ready) fprintf (f, " availability:%s", cgraph_availability_names [cgraph_function_body_availability (node)]); + if (node->analyzed) + fprintf (f, " analyzed"); + if (node->in_other_partition) + fprintf (f, " in_other_partition"); if (node->count) fprintf (f, " executed "HOST_WIDEST_INT_PRINT_DEC"x", (HOST_WIDEST_INT)node->count); @@ -1666,6 +1673,8 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node) fprintf (f, " address_taken"); else if (node->reachable) fprintf (f, " reachable"); + else if (node->reachable_from_other_partition) + fprintf (f, " reachable_from_other_partition"); if (gimple_has_body_p (node->decl)) fprintf (f, " body"); if (node->process) diff --git a/gcc/cgraph.h b/gcc/cgraph.h index dc6168a83ac..6bc565a2d17 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -249,11 +249,15 @@ struct GTY((chain_next ("%h.next"), chain_prev ("%h.previous"))) cgraph_node { cgraph_remove_unreachable_nodes cgraph still can contain unreachable nodes when they are needed for virtual clone instantiation. */ unsigned reachable : 1; + /* Set when function is reachable by call from other LTRANS partition. */ + unsigned reachable_from_other_partition : 1; /* Set once the function is lowered (i.e. its CFG is built). */ unsigned lowered : 1; /* Set once the function has been instantiated and its callee lists created. */ unsigned analyzed : 1; + /* Set when function is available in the other LTO partition. */ + unsigned in_other_partition : 1; /* Set when function is scheduled to be processed by local passes. */ unsigned process : 1; /* Set for aliases once they got through assemble_alias. */ @@ -723,7 +727,7 @@ cgraph_only_called_directly_p (struct cgraph_node *node) static inline bool cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node) { - return (!node->needed + return (!node->needed && !node->reachable_from_other_partition && (DECL_COMDAT (node->decl) || !node->local.externally_visible)); } diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c index 8fe3a879534..608a4af7c46 100644 --- a/gcc/cgraphunit.c +++ b/gcc/cgraphunit.c @@ -1146,7 +1146,7 @@ cgraph_mark_functions_to_output (void) outside the current compilation unit. */ if (node->analyzed && !node->global.inlined_to - && (node->needed + && (node->needed || node->reachable_from_other_partition || (e && node->reachable)) && !TREE_ASM_WRITTEN (decl) && !DECL_EXTERNAL (decl)) @@ -1173,6 +1173,10 @@ cgraph_mark_functions_to_output (void) #ifdef ENABLE_CHECKING if (!node->global.inlined_to && gimple_has_body_p (decl) + /* FIXME: in ltrans unit when offline copy is outside partition but inline copies + are inside partition, we can end up not removing the body since we no longer + have analyzed node pointing to it. */ + && !node->in_other_partition && !DECL_EXTERNAL (decl)) { dump_cgraph_node (stderr, node); @@ -1181,6 +1185,7 @@ cgraph_mark_functions_to_output (void) #endif gcc_assert (node->global.inlined_to || !gimple_has_body_p (decl) + || node->in_other_partition || DECL_EXTERNAL (decl)); } @@ -1194,6 +1199,10 @@ cgraph_mark_functions_to_output (void) tree decl = node->decl; if (!node->global.inlined_to && gimple_has_body_p (decl) + /* FIXME: in ltrans unit when offline copy is outside partition but inline copies + are inside partition, we can end up not removing the body since we no longer + have analyzed node pointing to it. */ + && !node->in_other_partition && !DECL_EXTERNAL (decl)) { dump_cgraph_node (stderr, node); @@ -2276,6 +2285,7 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e) gsi = gsi_for_stmt (e->call_stmt); gsi_replace (&gsi, new_stmt, true); + update_stmt (new_stmt); /* Update EH information too, just in case. */ maybe_clean_or_replace_eh_stmt (e->call_stmt, new_stmt); @@ -2379,6 +2389,7 @@ cgraph_materialize_all_clones (void) push_cfun (DECL_STRUCT_FUNCTION (node->decl)); for (e = node->callees; e; e = e->next_callee) cgraph_redirect_edge_call_stmt_to_callee (e); + gcc_assert (!need_ssa_update_p (cfun)); pop_cfun (); current_function_decl = NULL; #ifdef ENABLE_CHECKING diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md index 2d5003bcfee..9682ba12d25 100644 --- a/gcc/config/arm/arm.md +++ b/gcc/config/arm/arm.md @@ -3533,17 +3533,11 @@ (define_expand "negdi2" [(parallel - [(set (match_operand:DI 0 "s_register_operand" "") - (neg:DI (match_operand:DI 1 "s_register_operand" ""))) + [(set (match_operand:DI 0 "s_register_operand" "") + (neg:DI (match_operand:DI 1 "s_register_operand" ""))) (clobber (reg:CC CC_REGNUM))])] "TARGET_EITHER" - " - if (TARGET_THUMB1) - { - if (GET_CODE (operands[1]) != REG) - operands[1] = force_reg (DImode, operands[1]); - } - " + "" ) ;; The constraints here are to prevent a *partial* overlap (where %Q0 == %R1). @@ -3559,8 +3553,8 @@ ) (define_insn "*thumb1_negdi2" - [(set (match_operand:DI 0 "register_operand" "=&l") - (neg:DI (match_operand:DI 1 "register_operand" "l"))) + [(set (match_operand:DI 0 "register_operand" "=&l") + (neg:DI (match_operand:DI 1 "register_operand" "l"))) (clobber (reg:CC CC_REGNUM))] "TARGET_THUMB1" "mov\\t%R0, #0\;neg\\t%Q0, %Q1\;sbc\\t%R0, %R1" diff --git a/gcc/config/arm/bpabi-v6m.S b/gcc/config/arm/bpabi-v6m.S index 75d50d967a7..db1d0ed2529 100644 --- a/gcc/config/arm/bpabi-v6m.S +++ b/gcc/config/arm/bpabi-v6m.S @@ -22,6 +22,16 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ +#ifdef __ARM_EABI__ +/* Some attributes that are common to all routines in this file. */ + /* Tag_ABI_align_needed: This code does not require 8-byte + alignment from the caller. */ + /* .eabi_attribute 24, 0 -- default setting. */ + /* Tag_ABI_align_preserved: This code preserves 8-byte + alignment in any callee. */ + .eabi_attribute 25, 1 +#endif /* __ARM_EABI__ */ + #ifdef L_aeabi_lcmp FUNC_START aeabi_lcmp diff --git a/gcc/config/arm/bpabi.S b/gcc/config/arm/bpabi.S index ccc569e9821..10e0f95654d 100644 --- a/gcc/config/arm/bpabi.S +++ b/gcc/config/arm/bpabi.S @@ -22,6 +22,16 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ +#ifdef __ARM_EABI__ +/* Some attributes that are common to all routines in this file. */ + /* Tag_ABI_align_needed: This code does not require 8-byte + alignment from the caller. */ + /* .eabi_attribute 24, 0 -- default setting. */ + /* Tag_ABI_align_preserved: This code preserves 8-byte + alignment in any callee. */ + .eabi_attribute 25, 1 +#endif /* __ARM_EABI__ */ + #ifdef L_aeabi_lcmp ARM_FUNC_START aeabi_lcmp diff --git a/gcc/config/arm/crti.asm b/gcc/config/arm/crti.asm index 310d7840dee..bda56c56fe8 100644 --- a/gcc/config/arm/crti.asm +++ b/gcc/config/arm/crti.asm @@ -35,6 +35,15 @@ #else #define TYPE(x) #endif +#ifdef __ARM_EABI__ +/* Some attributes that are common to all routines in this file. */ + /* Tag_ABI_align_needed: This code does not require 8-byte + alignment from the caller. */ + /* .eabi_attribute 24, 0 -- default setting. */ + /* Tag_ABI_align_preserved: This code preserves 8-byte + alignment in any callee. */ + .eabi_attribute 25, 1 +#endif /* __ARM_EABI__ */ # Note - this macro is complemented by the FUNC_END macro # in crtn.asm. If you change this macro you must also change diff --git a/gcc/config/arm/crtn.asm b/gcc/config/arm/crtn.asm index 006b7d5260a..e4d59803ad1 100644 --- a/gcc/config/arm/crtn.asm +++ b/gcc/config/arm/crtn.asm @@ -26,6 +26,16 @@ .previous #endif +#ifdef __ARM_EABI__ +/* Some attributes that are common to all routines in this file. */ + /* Tag_ABI_align_needed: This code does not require 8-byte + alignment from the caller. */ + /* .eabi_attribute 24, 0 -- default setting. */ + /* Tag_ABI_align_preserved: This code preserves 8-byte + alignment in any callee. */ + .eabi_attribute 25, 1 +#endif /* __ARM_EABI__ */ + # This file just makes sure that the .fini and .init sections do in # fact return. Users may put any desired instructions in those sections. # This file is the last thing linked into any executable. diff --git a/gcc/config/arm/lib1funcs.asm b/gcc/config/arm/lib1funcs.asm index cd64da35860..34aa23e6979 100644 --- a/gcc/config/arm/lib1funcs.asm +++ b/gcc/config/arm/lib1funcs.asm @@ -31,10 +31,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #ifdef __ARM_EABI__ /* Some attributes that are common to all routines in this file. */ - /* Tag_ABI_align8_needed: This code does not require 8-byte + /* Tag_ABI_align_needed: This code does not require 8-byte alignment from the caller. */ /* .eabi_attribute 24, 0 -- default setting. */ - /* Tag_ABI_align8_preserved: This code preserves 8-byte + /* Tag_ABI_align_preserved: This code preserves 8-byte alignment in any callee. */ .eabi_attribute 25, 1 #endif /* __ARM_EABI__ */ diff --git a/gcc/config/arm/libunwind.S b/gcc/config/arm/libunwind.S index 800e7e0caa9..b04e41731fa 100644 --- a/gcc/config/arm/libunwind.S +++ b/gcc/config/arm/libunwind.S @@ -27,6 +27,16 @@ .previous #endif +#ifdef __ARM_EABI__ +/* Some attributes that are common to all routines in this file. */ + /* Tag_ABI_align_needed: This code does not require 8-byte + alignment from the caller. */ + /* .eabi_attribute 24, 0 -- default setting. */ + /* Tag_ABI_align_preserved: This code preserves 8-byte + alignment in any callee. */ + .eabi_attribute 25, 1 +#endif /* __ARM_EABI__ */ + #ifndef __symbian__ #include "lib1funcs.asm" diff --git a/gcc/config/avr/avr-devices.c b/gcc/config/avr/avr-devices.c index ad58772b2a1..86006c8ba8a 100755 --- a/gcc/config/avr/avr-devices.c +++ b/gcc/config/avr/avr-devices.c @@ -23,7 +23,7 @@ #include "coretypes.h" #include "tm.h" -/* List of all known AVR MCU architectyres. */ +/* List of all known AVR MCU architectures. */ const struct base_arch_s avr_arch_types[] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0060, NULL, "avr2" }, /* unknown device specified */ @@ -67,15 +67,23 @@ const struct mcu_type_s avr_mcu_types[] = { { "attiny13", ARCH_AVR25, "__AVR_ATtiny13__", 1, 0x0060, "tn13" }, { "attiny13a", ARCH_AVR25, "__AVR_ATtiny13A__", 1, 0x0060, "tn13a" }, { "attiny2313", ARCH_AVR25, "__AVR_ATtiny2313__", 1, 0x0060, "tn2313" }, + { "attiny2313a", ARCH_AVR25, "__AVR_ATtiny2313A__", 1, 0x0060, "tn2313a" }, { "attiny24", ARCH_AVR25, "__AVR_ATtiny24__", 1, 0x0060, "tn24" }, + { "attiny24a", ARCH_AVR25, "__AVR_ATtiny24A__" 1, 0x0060, "tn24a" }, + { "attiny4313", ARCH_AVR25, "__AVR_ATtiny4313__" 1, 0x0060, "tn4313" }, { "attiny44", ARCH_AVR25, "__AVR_ATtiny44__", 0, 0x0060, "tn44" }, + { "attiny44a", ARCH_AVR25, "__AVR_ATtiny44A__" 0, 0x0060, "tn44a" }, { "attiny84", ARCH_AVR25, "__AVR_ATtiny84__", 0, 0x0060, "tn84" }, + { "attiny84a", ARCH_AVR25, "__AVR_ATtiny84A__" 0, 0x0060, "tn84" }, { "attiny25", ARCH_AVR25, "__AVR_ATtiny25__", 1, 0x0060, "tn25" }, { "attiny45", ARCH_AVR25, "__AVR_ATtiny45__", 0, 0x0060, "tn45" }, { "attiny85", ARCH_AVR25, "__AVR_ATtiny85__", 0, 0x0060, "tn85" }, { "attiny261", ARCH_AVR25, "__AVR_ATtiny261__", 1, 0x0060, "tn261" }, + { "attiny261a", ARCH_AVR25, "__AVR_ATtiny261A__" 1, 0x0060, "tn261a" }, { "attiny461", ARCH_AVR25, "__AVR_ATtiny461__", 0, 0x0060, "tn461" }, + { "attiny461a", ARCH_AVR25, "__AVR_ATtiny461A__" 0, 0x0060, "tn461a" }, { "attiny861", ARCH_AVR25, "__AVR_ATtiny861__", 0, 0x0060, "tn861" }, + { "attiny861a", ARCH_AVR25, "__AVR_ATtiny861A__" 0, 0x0060, "tn861a" }, { "attiny43u", ARCH_AVR25, "__AVR_ATtiny43U__", 0, 0x0060, "tn43u" }, { "attiny87", ARCH_AVR25, "__AVR_ATtiny87__", 0, 0x0100, "tn87" }, { "attiny48", ARCH_AVR25, "__AVR_ATtiny48__", 0, 0x0100, "tn48" }, @@ -97,21 +105,19 @@ const struct mcu_type_s avr_mcu_types[] = { { "atmega16u2", ARCH_AVR35, "__AVR_ATmega16U2__", 0, 0x0100, "m16u2" }, { "atmega32u2", ARCH_AVR35, "__AVR_ATmega32U2__", 0, 0x0100, "m32u2" }, { "attiny167", ARCH_AVR35, "__AVR_ATtiny167__", 0, 0x0100, "tn167" }, - { "attiny327", ARCH_AVR35, "__AVR_ATtiny327__", 0, 0x0100, "tn327" }, /* Enhanced, <= 8K. */ { "avr4", ARCH_AVR4, NULL, 0, 0x0060, "m8" }, { "atmega8", ARCH_AVR4, "__AVR_ATmega8__", 0, 0x0060, "m8" }, { "atmega48", ARCH_AVR4, "__AVR_ATmega48__", 0, 0x0100, "m48" }, + { "atmega48a", ARCH_AVR4, "__AVR_ATmega48A__" 0, 0x0100, "m48a" }, { "atmega48p", ARCH_AVR4, "__AVR_ATmega48P__", 0, 0x0100, "m48p" }, { "atmega88", ARCH_AVR4, "__AVR_ATmega88__", 0, 0x0100, "m88" }, + { "atmega88a", ARCH_AVR4, "__AVR_ATmega88A__" 0, 0x0100, "m88a" }, { "atmega88p", ARCH_AVR4, "__AVR_ATmega88P__", 0, 0x0100, "m88p" }, + { "atmega88pa", ARCH_AVR4, "__AVR_ATmega88PA__" 0, 0x0100, "m88pa" }, { "atmega8515", ARCH_AVR4, "__AVR_ATmega8515__", 0, 0x0060, "m8515" }, { "atmega8535", ARCH_AVR4, "__AVR_ATmega8535__", 0, 0x0060, "m8535" }, - { "atmega8c1", ARCH_AVR4, "__AVR_ATmega8C1__", 0, 0x0100, "m8c1" }, - { "atmega8m1", ARCH_AVR4, "__AVR_ATmega8M1__", 0, 0x0100, "m8m1" }, { "atmega8hva", ARCH_AVR4, "__AVR_ATmega8HVA__", 0, 0x0100, "m8hva" }, - { "atmega4hvd", ARCH_AVR4, "__AVR_ATmega4HVD__", 0, 0x0100, "m4hvd" }, - { "atmega8hvd", ARCH_AVR4, "__AVR_ATmega8HVD__", 0, 0x0100, "m8hvd" }, { "at90pwm1", ARCH_AVR4, "__AVR_AT90PWM1__", 0, 0x0100, "90pwm1" }, { "at90pwm2", ARCH_AVR4, "__AVR_AT90PWM2__", 0, 0x0100, "90pwm2" }, { "at90pwm2b", ARCH_AVR4, "__AVR_AT90PWM2B__", 0, 0x0100, "90pwm2b" }, @@ -121,45 +127,68 @@ const struct mcu_type_s avr_mcu_types[] = { /* Enhanced, > 8K, <= 64K. */ { "avr5", ARCH_AVR5, NULL, 0, 0x0060, "m16" }, { "atmega16", ARCH_AVR5, "__AVR_ATmega16__", 0, 0x0060, "m16" }, + { "atmega16a", ARCH_AVR5, "__AVR_ATmega16A__" 0, 0x0060, "m16a" }, { "atmega161", ARCH_AVR5, "__AVR_ATmega161__", 0, 0x0060, "m161" }, { "atmega162", ARCH_AVR5, "__AVR_ATmega162__", 0, 0x0100, "m162" }, { "atmega163", ARCH_AVR5, "__AVR_ATmega163__", 0, 0x0060, "m163" }, + { "atmega164a", ARCH_AVR5, "__AVR_ATmega164A__" 0, 0x0060, "m164a" }, { "atmega164p", ARCH_AVR5, "__AVR_ATmega164P__", 0, 0x0100, "m164p" }, { "atmega165", ARCH_AVR5, "__AVR_ATmega165__", 0, 0x0100, "m165" }, + { "atmega165a", ARCH_AVR5, "__AVR_ATmega165A__" 0, 0x0100, "m165a" }, { "atmega165p", ARCH_AVR5, "__AVR_ATmega165P__", 0, 0x0100, "m165p" }, { "atmega168", ARCH_AVR5, "__AVR_ATmega168__", 0, 0x0100, "m168" }, + { "atmega168a", ARCH_AVR5, "__AVR_ATmega168A__" 0, 0x0100, "m168a" }, { "atmega168p", ARCH_AVR5, "__AVR_ATmega168P__", 0, 0x0100, "m168p" }, { "atmega169", ARCH_AVR5, "__AVR_ATmega169__", 0, 0x0100, "m169" }, + { "atmega169a", ARCH_AVR5, "__AVR_ATmega169A__" 0, 0x0100, "m169a" }, { "atmega169p", ARCH_AVR5, "__AVR_ATmega169P__", 0, 0x0100, "m169p" }, + { "atmega169pa", ARCH_AVR5, "__AVR_ATmega169PA__" 0, 0x0100, "m169pa" }, { "atmega32", ARCH_AVR5, "__AVR_ATmega32__", 0, 0x0060, "m32" }, { "atmega323", ARCH_AVR5, "__AVR_ATmega323__", 0, 0x0060, "m323" }, + { "atmega324a", ARCH_AVR5, "__AVR_ATmega324A__" 0, 0x0100, "m324a" }, { "atmega324p", ARCH_AVR5, "__AVR_ATmega324P__", 0, 0x0100, "m324p" }, + { "atmega324pa", ARCH_AVR5, "__AVR_ATmega324PA__" 0, 0x0100, "m324pa" }, { "atmega325", ARCH_AVR5, "__AVR_ATmega325__", 0, 0x0100, "m325" }, + { "atmega325a", ARCH_AVR5, "__AVR_ATmega325A__" 0, 0x0100, "m325a" }, { "atmega325p", ARCH_AVR5, "__AVR_ATmega325P__", 0, 0x0100, "m325p" }, { "atmega3250", ARCH_AVR5, "__AVR_ATmega3250__", 0, 0x0100, "m3250" }, + { "atmega3250a", ARCH_AVR5, "__AVR_ATmega3250A__" 0, 0x0100, "m3250a" }, { "atmega3250p", ARCH_AVR5, "__AVR_ATmega3250P__", 0, 0x0100, "m3250p" }, + { "atmega328", ARCH_AVR5, "__AVR_ATmega328__" 0, 0x0100, "m328" }, { "atmega328p", ARCH_AVR5, "__AVR_ATmega328P__", 0, 0x0100, "m328p" }, { "atmega329", ARCH_AVR5, "__AVR_ATmega329__", 0, 0x0100, "m329" }, + { "atmega329a", ARCH_AVR5, "__AVR_ATmega329A__" 0, 0x0100, "m329a" }, { "atmega329p", ARCH_AVR5, "__AVR_ATmega329P__", 0, 0x0100, "m329p" }, + { "atmega329pa", ARCH_AVR5, "__AVR_ATmega329PA__" 0, 0x0100, "m329pa" }, { "atmega3290", ARCH_AVR5, "__AVR_ATmega3290__", 0, 0x0100, "m3290" }, + { "atmega3290a", ARCH_AVR5, "__AVR_ATmega3290A__" 0, 0x0100, "m3290a" }, { "atmega3290p", ARCH_AVR5, "__AVR_ATmega3290P__", 0, 0x0100, "m3290p" }, { "atmega406", ARCH_AVR5, "__AVR_ATmega406__", 0, 0x0100, "m406" }, { "atmega64", ARCH_AVR5, "__AVR_ATmega64__", 0, 0x0100, "m64" }, { "atmega640", ARCH_AVR5, "__AVR_ATmega640__", 0, 0x0200, "m640" }, { "atmega644", ARCH_AVR5, "__AVR_ATmega644__", 0, 0x0100, "m644" }, + { "atmega644a", ARCH_AVR5, "__AVR_ATmega644A__" 0, 0x0100, "m644a" }, { "atmega644p", ARCH_AVR5, "__AVR_ATmega644P__", 0, 0x0100, "m644p" }, + { "atmega644pa", ARCH_AVR5, "__AVR_ATmega644PA__" 0, 0x0100, "m644pa" }, { "atmega645", ARCH_AVR5, "__AVR_ATmega645__", 0, 0x0100, "m645" }, + { "atmega645a", ARCH_AVR5, "__AVR_ATmega645A__" 0, 0x0100, "m645a" }, + { "atmega645p", ARCH_AVR5, "__AVR_ATmega645P__" 0, 0x0100, "m645p" }, { "atmega6450", ARCH_AVR5, "__AVR_ATmega6450__", 0, 0x0100, "m6450" }, + { "atmega6450a", ARCH_AVR5, "__AVR_ATmega6450A__" 0, 0x0100, "m6450a" }, + { "atmega6450p", ARCH_AVR5, "__AVR_ATmega6450P__" 0, 0x0100, "m6450p" }, { "atmega649", ARCH_AVR5, "__AVR_ATmega649__", 0, 0x0100, "m649" }, + { "atmega649a", ARCH_AVR5, "__AVR_ATmega649A__" 0, 0x0100, "m649a" }, + { "atmega649p", ARCH_AVR5, "__AVR_ATmega649P__" 0, 0x0100, "m649p" }, { "atmega6490", ARCH_AVR5, "__AVR_ATmega6490__", 0, 0x0100, "m6490" }, { "atmega16hva", ARCH_AVR5, "__AVR_ATmega16HVA__", 0, 0x0100, "m16hva" }, + { "atmega16hva2", ARCH_AVR5, "__AVR_ATmega16HVA2__" 0, 0x0100, "m16hva2" }, { "atmega16hvb", ARCH_AVR5, "__AVR_ATmega16HVB__", 0, 0x0100, "m16hvb" }, - { "atmega32hvb", ARCH_AVR5, "__AVR_ATmega32HVB__", 0, 0x0100, "m23hvb" }, + { "atmega32hvb", ARCH_AVR5, "__AVR_ATmega32HVB__", 0, 0x0100, "m32hvb" }, + { "atmega64hve", ARCH_AVR5, "__AVR_ATmega64HVE__" 0, 0x0100, "m64hve" }, { "at90can32", ARCH_AVR5, "__AVR_AT90CAN32__", 0, 0x0100, "can32" }, { "at90can64", ARCH_AVR5, "__AVR_AT90CAN64__", 0, 0x0100, "can64" }, { "at90pwm216", ARCH_AVR5, "__AVR_AT90PWM216__", 0, 0x0100, "90pwm216" }, { "at90pwm316", ARCH_AVR5, "__AVR_AT90PWM316__", 0, 0x0100, "90pwm316" }, - { "atmega16c1", ARCH_AVR5, "__AVR_ATmega16C1__", 0, 0x0100, "m16c1" }, { "atmega32c1", ARCH_AVR5, "__AVR_ATmega32C1__", 0, 0x0100, "m32c1" }, { "atmega64c1", ARCH_AVR5, "__AVR_ATmega64C1__", 0, 0x0100, "m64c1" }, { "atmega16m1", ARCH_AVR5, "__AVR_ATmega16M1__", 0, 0x0100, "m16m1" }, @@ -172,6 +201,7 @@ const struct mcu_type_s avr_mcu_types[] = { { "at90usb646", ARCH_AVR5, "__AVR_AT90USB646__", 0, 0x0100, "usb646" }, { "at90usb647", ARCH_AVR5, "__AVR_AT90USB647__", 0, 0x0100, "usb647" }, { "at94k", ARCH_AVR5, "__AVR_AT94K__", 0, 0x0060, "at94k" }, + { "m3000", ARCH_AVR5, "__AVR_M3000__", 0, 0x1000, "m3000" }, /* Enhanced, == 128K. */ { "avr51", ARCH_AVR51, NULL, 0, 0x0100, "m128" }, { "atmega128", ARCH_AVR51, "__AVR_ATmega128__", 0, 0x0100, "m128" }, @@ -182,9 +212,6 @@ const struct mcu_type_s avr_mcu_types[] = { { "at90can128", ARCH_AVR51, "__AVR_AT90CAN128__", 0, 0x0100, "can128" }, { "at90usb1286", ARCH_AVR51, "__AVR_AT90USB1286__", 0, 0x0100, "usb1286" }, { "at90usb1287", ARCH_AVR51, "__AVR_AT90USB1287__", 0, 0x0100, "usb1286" }, - { "m3000f", ARCH_AVR51, "__AVR_M3000F__", 0, 0x1000, "m3000f" }, - { "m3000s", ARCH_AVR51, "__AVR_M3000S__", 0, 0x1000, "m3000f" }, - { "m3001b", ARCH_AVR51, "__AVR_M3001B__", 0, 0x1000, "m3000f" }, /* 3-Byte PC. */ { "avr6", ARCH_AVR6, NULL, 0, 0x0200, "m2561" }, { "atmega2560", ARCH_AVR6, "__AVR_ATmega2560__", 0, 0x0200, "m2561" }, diff --git a/gcc/config/avr/t-avr b/gcc/config/avr/t-avr index 91d1fe86fbc..1d57a0b3421 100644 --- a/gcc/config/avr/t-avr +++ b/gcc/config/avr/t-avr @@ -81,15 +81,23 @@ MULTILIB_MATCHES = \ mmcu?avr25=mmcu?attiny13 \ mmcu?avr25=mmcu?attiny13a \ mmcu?avr25=mmcu?attiny2313 \ + mmcu?avr25=mmcu?attiny2313a \ + mmcu?avr25=mmcu?attiny4313 \ mmcu?avr25=mmcu?attiny24 \ + mmcu?avr25=mmcu?attiny24a \ mmcu?avr25=mmcu?attiny44 \ + mmcu?avr25=mmcu?attiny44a \ mmcu?avr25=mmcu?attiny84 \ + mmcu?avr25=mmcu?attiny84a \ mmcu?avr25=mmcu?attiny25 \ mmcu?avr25=mmcu?attiny45 \ mmcu?avr25=mmcu?attiny85 \ mmcu?avr25=mmcu?attiny261 \ + mmcu?avr25=mmcu?attiny261a \ mmcu?avr25=mmcu?attiny461 \ + mmcu?avr25=mmcu?attiny461a \ mmcu?avr25=mmcu?attiny861 \ + mmcu?avr25=mmcu?attiny861a \ mmcu?avr25=mmcu?attiny43u \ mmcu?avr25=mmcu?attiny87 \ mmcu?avr25=mmcu?attiny48 \ @@ -105,19 +113,17 @@ MULTILIB_MATCHES = \ mmcu?avr35=mmcu?atmega16u2 \ mmcu?avr35=mmcu?atmega32u2 \ mmcu?avr35=mmcu?attiny167 \ - mmcu?avr35=mmcu?attiny327 \ mmcu?avr4=mmcu?atmega48 \ + mmcu?avr4=mmcu?atmega48a \ mmcu?avr4=mmcu?atmega48p \ mmcu?avr4=mmcu?atmega8 \ mmcu?avr4=mmcu?atmega8515 \ mmcu?avr4=mmcu?atmega8535 \ mmcu?avr4=mmcu?atmega88 \ + mmcu?avr4=mmcu?atmega88a \ mmcu?avr4=mmcu?atmega88p \ + mmcu?avr4=mmcu?atmega88pa \ mmcu?avr4=mmcu?atmega8hva \ - mmcu?avr4=mmcu?atmega4hvd \ - mmcu?avr4=mmcu?atmega8hvd \ - mmcu?avr4=mmcu?atmega8c1 \ - mmcu?avr4=mmcu?atmega8m1 \ mmcu?avr4=mmcu?at90pwm1 \ mmcu?avr4=mmcu?at90pwm2 \ mmcu?avr4=mmcu?at90pwm2b \ @@ -125,45 +131,70 @@ MULTILIB_MATCHES = \ mmcu?avr4=mmcu?at90pwm3b \ mmcu?avr4=mmcu?at90pwm81 \ mmcu?avr5=mmcu?atmega16 \ + mmcu?avr5=mmcu?atmega16a \ mmcu?avr5=mmcu?atmega161 \ mmcu?avr5=mmcu?atmega162 \ mmcu?avr5=mmcu?atmega163 \ + mmcu?avr5=mmcu?atmega164a \ mmcu?avr5=mmcu?atmega164p \ mmcu?avr5=mmcu?atmega165 \ + mmcu?avr5=mmcu?atmega165a \ mmcu?avr5=mmcu?atmega165p \ mmcu?avr5=mmcu?atmega168 \ + mmcu?avr5=mmcu?atmega168a \ mmcu?avr5=mmcu?atmega168p \ mmcu?avr5=mmcu?atmega169 \ + mmcu?avr5=mmcu?atmega169a \ mmcu?avr5=mmcu?atmega169p \ + mmcu?avr5=mmcu?atmega169pa \ mmcu?avr5=mmcu?atmega32 \ mmcu?avr5=mmcu?atmega323 \ + mmcu?avr5=mmcu?atmega324a \ mmcu?avr5=mmcu?atmega324p \ + mmcu?avr5=mmcu?atmega324pa \ mmcu?avr5=mmcu?atmega325 \ + mmcu?avr5=mmcu?atmega325a \ mmcu?avr5=mmcu?atmega325p \ mmcu?avr5=mmcu?atmega3250 \ + mmcu?avr5=mmcu?atmega3250a \ mmcu?avr5=mmcu?atmega3250p \ + mmcu?avr5=mmcu?atmega328 \ mmcu?avr5=mmcu?atmega328p \ mmcu?avr5=mmcu?atmega329 \ + mmcu?avr5=mmcu?atmega329a \ mmcu?avr5=mmcu?atmega329p \ + mmcu?avr5=mmcu?atmega329pa \ mmcu?avr5=mmcu?atmega3290 \ + mmcu?avr5=mmcu?atmega3290a \ mmcu?avr5=mmcu?atmega3290p \ mmcu?avr5=mmcu?atmega406 \ mmcu?avr5=mmcu?atmega64 \ mmcu?avr5=mmcu?atmega640 \ mmcu?avr5=mmcu?atmega644 \ + mmcu?avr5=mmcu?atmega644a \ mmcu?avr5=mmcu?atmega644p \ + mmcu?avr5=mmcu?atmega644pa \ mmcu?avr5=mmcu?atmega645 \ + mmcu?avr5=mmcu?atmega645a \ + mmcu?avr5=mmcu?atmega645p \ mmcu?avr5=mmcu?atmega6450 \ + mmcu?avr5=mmcu?atmega6450a \ + mmcu?avr5=mmcu?atmega6450p \ mmcu?avr5=mmcu?atmega649 \ + mmcu?avr5=mmcu?atmega649a \ + mmcu?avr5=mmcu?atmega649p \ mmcu?avr5=mmcu?atmega6490 \ + mmcu?avr5=mmcu?atmega6490a \ + mmcu?avr5=mmcu?atmega6490p \ mmcu?avr5=mmcu?atmega16hva \ + mmcu?avr5=mmcu?atmega16hva2 \ mmcu?avr5=mmcu?atmega16hvb \ mmcu?avr5=mmcu?atmega32hvb \ + mmcu?avr5=mmcu?atmega64hve \ mmcu?avr5=mmcu?at90can32 \ mmcu?avr5=mmcu?at90can64 \ mmcu?avr5=mmcu?at90pwm216 \ mmcu?avr5=mmcu?at90pwm316 \ - mmcu?avr5=mmcu?atmega16c1 \ mmcu?avr5=mmcu?atmega32c1 \ mmcu?avr5=mmcu?atmega64c1 \ mmcu?avr5=mmcu?atmega16m1 \ @@ -176,6 +207,7 @@ MULTILIB_MATCHES = \ mmcu?avr5=mmcu?at90usb646 \ mmcu?avr5=mmcu?at90usb647 \ mmcu?avr5=mmcu?at94k \ + mmcu?avr5=mmcu?m3000 \ mmcu?avr51=mmcu?atmega128 \ mmcu?avr51=mmcu?atmega1280 \ mmcu?avr51=mmcu?atmega1281 \ @@ -184,9 +216,6 @@ MULTILIB_MATCHES = \ mmcu?avr51=mmcu?at90can128 \ mmcu?avr51=mmcu?at90usb1286 \ mmcu?avr51=mmcu?at90usb1287 \ - mmcu?avr51=mmcu?m3000f \ - mmcu?avr51=mmcu?m3000s \ - mmcu?avr51=mmcu?m3001b \ mmcu?avr6=mmcu?atmega2560 \ mmcu?avr6=mmcu?atmega2561 diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index b99fe2ae345..f91410a2d66 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -6790,7 +6790,6 @@ setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum) { rtx save_area, mem; rtx label; - rtx label_ref; rtx tmp_reg; rtx nsse_reg; alias_set_type set; @@ -6841,35 +6840,9 @@ setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum) SSE saves. We need some preparation work to get this working. */ label = gen_label_rtx (); - label_ref = gen_rtx_LABEL_REF (Pmode, label); - /* Compute address to jump to : - label - eax*4 + nnamed_sse_arguments*4 Or - label - eax*5 + nnamed_sse_arguments*5 for AVX. */ - tmp_reg = gen_reg_rtx (Pmode); nsse_reg = gen_reg_rtx (Pmode); emit_insn (gen_zero_extendqidi2 (nsse_reg, gen_rtx_REG (QImode, AX_REG))); - emit_insn (gen_rtx_SET (VOIDmode, tmp_reg, - gen_rtx_MULT (Pmode, nsse_reg, - GEN_INT (4)))); - - /* vmovaps is one byte longer than movaps. */ - if (TARGET_AVX) - emit_insn (gen_rtx_SET (VOIDmode, tmp_reg, - gen_rtx_PLUS (Pmode, tmp_reg, - nsse_reg))); - - if (cum->sse_regno) - emit_move_insn - (nsse_reg, - gen_rtx_CONST (DImode, - gen_rtx_PLUS (DImode, - label_ref, - GEN_INT (cum->sse_regno - * (TARGET_AVX ? 5 : 4))))); - else - emit_move_insn (nsse_reg, label_ref); - emit_insn (gen_subdi3 (nsse_reg, nsse_reg, tmp_reg)); /* Compute address of memory block we save into. We always use pointer pointing 127 bytes after first byte to store - this is needed to keep @@ -6882,11 +6855,12 @@ setup_incoming_varargs_64 (CUMULATIVE_ARGS *cum) mem = gen_rtx_MEM (BLKmode, plus_constant (tmp_reg, -127)); MEM_NOTRAP_P (mem) = 1; set_mem_alias_set (mem, set); - set_mem_align (mem, BITS_PER_WORD); + set_mem_align (mem, 64); /* And finally do the dirty job! */ emit_insn (gen_sse_prologue_save (mem, nsse_reg, - GEN_INT (cum->sse_regno), label)); + GEN_INT (cum->sse_regno), label, + gen_reg_rtx (Pmode))); } } @@ -7047,7 +7021,7 @@ ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p, int indirect_p = 0; tree ptrtype; enum machine_mode nat_mode; - int arg_boundary; + unsigned int arg_boundary; /* Only 64bit target needs something special. */ if (!TARGET_64BIT || is_va_list_char_pointer (TREE_TYPE (valist))) @@ -7279,6 +7253,8 @@ ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p, t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t, size_int (-align)); t = fold_convert (TREE_TYPE (ovf), t); + if (crtl->stack_alignment_needed < arg_boundary) + crtl->stack_alignment_needed = arg_boundary; } gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue); gimplify_assign (addr, t, pre_p); @@ -9381,6 +9357,7 @@ ix86_decompose_address (rtx addr, struct ix86_address *out) rtx base_reg, index_reg; HOST_WIDE_INT scale = 1; rtx scale_rtx = NULL_RTX; + rtx tmp; int retval = 1; enum ix86_address_seg seg = SEG_DEFAULT; @@ -9416,6 +9393,19 @@ ix86_decompose_address (rtx addr, struct ix86_address *out) scale_rtx = XEXP (op, 1); break; + case ASHIFT: + if (index) + return 0; + index = XEXP (op, 0); + tmp = XEXP (op, 1); + if (!CONST_INT_P (tmp)) + return 0; + scale = INTVAL (tmp); + if ((unsigned HOST_WIDE_INT) scale > 3) + return 0; + scale = 1 << scale; + break; + case UNSPEC: if (XINT (op, 1) == UNSPEC_TP && TARGET_TLS_DIRECT_SEG_REFS @@ -9456,8 +9446,6 @@ ix86_decompose_address (rtx addr, struct ix86_address *out) } else if (GET_CODE (addr) == ASHIFT) { - rtx tmp; - /* We're called for lea too, which implements ashift on occasion. */ index = XEXP (addr, 0); tmp = XEXP (addr, 1); @@ -20099,10 +20087,26 @@ ix86_local_alignment (tree exp, enum machine_mode mode, } /* x86-64 ABI requires arrays greater than 16 bytes to be aligned - to 16byte boundary. */ - if (TARGET_64BIT) + to 16byte boundary. Exact wording is: + + An array uses the same alignment as its elements, except that a local or + global array variable of length at least 16 bytes or + a C99 variable-length array variable always has alignment of at least 16 bytes. + + This was added to allow use of aligned SSE instructions at arrays. This + rule is meant for static storage (where compiler can not do the analysis + by itself). We follow it for automatic variables only when convenient. + We fully control everything in the function compiled and functions from + other unit can not rely on the alignment. + + Exclude va_list type. It is the common case of local array where + we can not benefit from the alignment. */ + if (TARGET_64BIT && optimize_function_for_speed_p (cfun) + && TARGET_SSE) { if (AGGREGATE_TYPE_P (type) + && (TYPE_MAIN_VARIANT (type) + != TYPE_MAIN_VARIANT (va_list_type_node)) && TYPE_SIZE (type) && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST && (TREE_INT_CST_LOW (TYPE_SIZE (type)) >= 16 diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index d08a7ea1081..8249efd31fd 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -85,6 +85,7 @@ (UNSPEC_SET_RIP 16) (UNSPEC_SET_GOT_OFFSET 17) (UNSPEC_MEMORY_BLOCKAGE 18) + (UNSPEC_SSE_PROLOGUE_SAVE_LOW 19) ; TLS support (UNSPEC_TP 20) @@ -2379,11 +2380,13 @@ && !x86_64_immediate_operand (operands[1], DImode) && 1" [(set (match_dup 0) (match_dup 1)) (set (match_dup 2) (match_dup 3))] - "split_di (&operands[1], 1, &operands[2], &operands[3]); - operands[1] = gen_lowpart (DImode, operands[2]); - operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx, - GEN_INT (4))); - ") +{ + split_di (&operands[1], 1, &operands[2], &operands[3]); + + operands[1] = gen_lowpart (DImode, operands[2]); + operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx, + GEN_INT (4))); +}) (define_split [(set (match_operand:DI 0 "push_operand" "") @@ -2394,11 +2397,13 @@ && !x86_64_immediate_operand (operands[1], DImode)" [(set (match_dup 0) (match_dup 1)) (set (match_dup 2) (match_dup 3))] - "split_di (&operands[1], 1, &operands[2], &operands[3]); - operands[1] = gen_lowpart (DImode, operands[2]); - operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx, - GEN_INT (4))); - ") +{ + split_di (&operands[1], 1, &operands[2], &operands[3]); + + operands[1] = gen_lowpart (DImode, operands[2]); + operands[2] = gen_rtx_MEM (SImode, gen_rtx_PLUS (DImode, stack_pointer_rtx, + GEN_INT (4))); +}) (define_insn "*pushdi2_prologue_rex64" [(set (match_operand:DI 0 "push_operand" "=<") @@ -7926,7 +7931,7 @@ (use (match_dup 1)) (clobber (reg:CC FLAGS_REG))])] { - operands[5] = GEN_INT (GET_MODE_BITSIZE (mode) - 1); + operands[5] = GEN_INT (GET_MODE_BITSIZE (mode)-1); if (mode != HImode && (optimize_function_for_size_p (cfun) || TARGET_USE_CLTD)) @@ -10318,8 +10323,10 @@ "shrd{l}\t{%s2%1, %0|%0, %1, %2}" [(set_attr "type" "ishift") (set_attr "prefix_0f" "1") + (set_attr "mode" "SI") (set_attr "pent_pair" "np") - (set_attr "mode" "SI")]) + (set_attr "athlon_decode" "vector") + (set_attr "amdfam10_decode" "vector")]) (define_insn "ashrdi3_cvt" [(set (match_operand:DI 0 "nonimmediate_operand" "=*d,rm") @@ -11532,6 +11539,7 @@ [(const_int 0)] { operands[7] = gen_rtx_FLOAT (GET_MODE (operands[1]), operands[2]); + ix86_split_fp_branch (swap_condition (GET_CODE (operands[0])), operands[3], operands[7], operands[4], operands[5], operands[6], NULL_RTX); @@ -11555,6 +11563,7 @@ { operands[7] = ix86_force_to_memory (GET_MODE (operands[2]), operands[2]); operands[7] = gen_rtx_FLOAT (GET_MODE (operands[1]), operands[7]); + ix86_split_fp_branch (swap_condition (GET_CODE (operands[0])), operands[3], operands[7], operands[4], operands[5], operands[6], operands[2]); @@ -12174,38 +12183,33 @@ "leave" [(set_attr "type" "leave")]) -(define_expand "ffssi2" - [(parallel - [(set (match_operand:SI 0 "register_operand" "") - (ffs:SI (match_operand:SI 1 "nonimmediate_operand" ""))) - (clobber (match_scratch:SI 2 "")) - (clobber (reg:CC FLAGS_REG))])] - "" -{ - if (TARGET_CMOVE) - { - emit_insn (gen_ffs_cmove (operands[0], operands[1])); - DONE; - } -}) +;; Bit manipulation instructions. -(define_expand "ffs_cmove" +(define_expand "ffs2" [(set (match_dup 2) (const_int -1)) (parallel [(set (reg:CCZ FLAGS_REG) - (compare:CCZ (match_operand:SI 1 "nonimmediate_operand" "") - (const_int 0))) - (set (match_operand:SI 0 "register_operand" "") - (ctz:SI (match_dup 1)))]) - (set (match_dup 0) (if_then_else:SI + (compare:CCZ + (match_operand:SWI48 1 "nonimmediate_operand" "") + (const_int 0))) + (set (match_operand:SWI48 0 "register_operand" "") + (ctz:SWI48 (match_dup 1)))]) + (set (match_dup 0) (if_then_else:SWI48 (eq (reg:CCZ FLAGS_REG) (const_int 0)) (match_dup 2) (match_dup 0))) - (parallel [(set (match_dup 0) (plus:SI (match_dup 0) (const_int 1))) + (parallel [(set (match_dup 0) (plus:SWI48 (match_dup 0) (const_int 1))) (clobber (reg:CC FLAGS_REG))])] - "TARGET_CMOVE" - "operands[2] = gen_reg_rtx (SImode);") + "" +{ + if (mode == SImode && !TARGET_CMOVE) + { + emit_insn (gen_ffssi2_no_cmove (operands[0], operands [1])); + DONE; + } + operands[2] = gen_reg_rtx (mode); +}) -(define_insn_and_split "*ffs_no_cmove" +(define_insn_and_split "ffssi2_no_cmove" [(set (match_operand:SI 0 "register_operand" "=r") (ffs:SI (match_operand:SI 1 "nonimmediate_operand" "rm"))) (clobber (match_scratch:SI 2 "=&q")) @@ -12229,93 +12233,68 @@ ix86_expand_clear (operands[2]); }) -(define_insn "*ffssi_1" +(define_insn "*ffs_1" [(set (reg:CCZ FLAGS_REG) - (compare:CCZ (match_operand:SI 1 "nonimmediate_operand" "rm") + (compare:CCZ (match_operand:SWI48 1 "nonimmediate_operand" "rm") (const_int 0))) - (set (match_operand:SI 0 "register_operand" "=r") - (ctz:SI (match_dup 1)))] + (set (match_operand:SWI48 0 "register_operand" "=r") + (ctz:SWI48 (match_dup 1)))] "" - "bsf{l}\t{%1, %0|%0, %1}" - [(set_attr "type" "alu1") - (set_attr "prefix_0f" "1") - (set_attr "mode" "SI")]) - -(define_expand "ffsdi2" - [(set (match_dup 2) (const_int -1)) - (parallel [(set (reg:CCZ FLAGS_REG) - (compare:CCZ (match_operand:DI 1 "nonimmediate_operand" "") - (const_int 0))) - (set (match_operand:DI 0 "register_operand" "") - (ctz:DI (match_dup 1)))]) - (set (match_dup 0) (if_then_else:DI - (eq (reg:CCZ FLAGS_REG) (const_int 0)) - (match_dup 2) - (match_dup 0))) - (parallel [(set (match_dup 0) (plus:DI (match_dup 0) (const_int 1))) - (clobber (reg:CC FLAGS_REG))])] - "TARGET_64BIT" - "operands[2] = gen_reg_rtx (DImode);") - -(define_insn "*ffsdi_1" - [(set (reg:CCZ FLAGS_REG) - (compare:CCZ (match_operand:DI 1 "nonimmediate_operand" "rm") - (const_int 0))) - (set (match_operand:DI 0 "register_operand" "=r") - (ctz:DI (match_dup 1)))] - "TARGET_64BIT" - "bsf{q}\t{%1, %0|%0, %1}" + "bsf{}\t{%1, %0|%0, %1}" [(set_attr "type" "alu1") (set_attr "prefix_0f" "1") - (set_attr "mode" "DI")]) + (set_attr "mode" "")]) -(define_insn "ctzsi2" - [(set (match_operand:SI 0 "register_operand" "=r") - (ctz:SI (match_operand:SI 1 "nonimmediate_operand" "rm"))) +(define_insn "ctz2" + [(set (match_operand:SWI48 0 "register_operand" "=r") + (ctz:SWI48 (match_operand:SWI48 1 "nonimmediate_operand" "rm"))) (clobber (reg:CC FLAGS_REG))] "" - "bsf{l}\t{%1, %0|%0, %1}" - [(set_attr "type" "alu1") - (set_attr "prefix_0f" "1") - (set_attr "mode" "SI")]) - -(define_insn "ctzdi2" - [(set (match_operand:DI 0 "register_operand" "=r") - (ctz:DI (match_operand:DI 1 "nonimmediate_operand" "rm"))) - (clobber (reg:CC FLAGS_REG))] - "TARGET_64BIT" - "bsf{q}\t{%1, %0|%0, %1}" + "bsf{}\t{%1, %0|%0, %1}" [(set_attr "type" "alu1") (set_attr "prefix_0f" "1") - (set_attr "mode" "DI")]) + (set_attr "mode" "")]) -(define_expand "clzsi2" +(define_expand "clz2" [(parallel - [(set (match_operand:SI 0 "register_operand" "") - (minus:SI (const_int 31) - (clz:SI (match_operand:SI 1 "nonimmediate_operand" "")))) + [(set (match_operand:SWI248 0 "register_operand" "") + (minus:SWI248 + (match_dup 2) + (clz:SWI248 (match_operand:SWI248 1 "nonimmediate_operand" "")))) (clobber (reg:CC FLAGS_REG))]) (parallel - [(set (match_dup 0) (xor:SI (match_dup 0) (const_int 31))) + [(set (match_dup 0) (xor:SWI248 (match_dup 0) (match_dup 2))) (clobber (reg:CC FLAGS_REG))])] "" { if (TARGET_ABM) { - emit_insn (gen_clzsi2_abm (operands[0], operands[1])); + emit_insn (gen_clz2_abm (operands[0], operands[1])); DONE; } + operands[2] = GEN_INT (GET_MODE_BITSIZE (mode)-1); }) -(define_insn "clzsi2_abm" - [(set (match_operand:SI 0 "register_operand" "=r") - (clz:SI (match_operand:SI 1 "nonimmediate_operand" "rm"))) +(define_insn "clz2_abm" + [(set (match_operand:SWI248 0 "register_operand" "=r") + (clz:SWI248 (match_operand:SWI248 1 "nonimmediate_operand" "rm"))) (clobber (reg:CC FLAGS_REG))] "TARGET_ABM" - "lzcnt{l}\t{%1, %0|%0, %1}" + "lzcnt{}\t{%1, %0|%0, %1}" [(set_attr "prefix_rep" "1") (set_attr "type" "bitmanip") - (set_attr "mode" "SI")]) + (set_attr "mode" "")]) + +(define_insn "bsr_rex64" + [(set (match_operand:DI 0 "register_operand" "=r") + (minus:DI (const_int 63) + (clz:DI (match_operand:DI 1 "nonimmediate_operand" "rm")))) + (clobber (reg:CC FLAGS_REG))] + "TARGET_64BIT" + "bsr{q}\t{%1, %0|%0, %1}" + [(set_attr "type" "alu1") + (set_attr "prefix_0f" "1") + (set_attr "mode" "DI")]) (define_insn "bsr" [(set (match_operand:SI 0 "register_operand" "=r") @@ -12328,6 +12307,17 @@ (set_attr "prefix_0f" "1") (set_attr "mode" "SI")]) +(define_insn "*bsrhi" + [(set (match_operand:HI 0 "register_operand" "=r") + (minus:HI (const_int 15) + (clz:HI (match_operand:HI 1 "nonimmediate_operand" "rm")))) + (clobber (reg:CC FLAGS_REG))] + "" + "bsr{w}\t{%1, %0|%0, %1}" + [(set_attr "type" "alu1") + (set_attr "prefix_0f" "1") + (set_attr "mode" "HI")]) + (define_insn "popcount2" [(set (match_operand:SWI248 0 "register_operand" "=r") (popcount:SWI248 @@ -12384,12 +12374,12 @@ (set_attr "type" "bitmanip") (set_attr "mode" "SI")]) -(define_expand "bswapsi2" - [(set (match_operand:SI 0 "register_operand" "") - (bswap:SI (match_operand:SI 1 "register_operand" "")))] +(define_expand "bswap2" + [(set (match_operand:SWI48 0 "register_operand" "") + (bswap:SWI48 (match_operand:SWI48 1 "register_operand" "")))] "" { - if (!(TARGET_BSWAP || TARGET_MOVBE)) + if (mode == SImode && !(TARGET_BSWAP || TARGET_MOVBE)) { rtx x = operands[0]; @@ -12401,28 +12391,29 @@ } }) -(define_insn "*bswapsi_movbe" - [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m") - (bswap:SI (match_operand:SI 1 "nonimmediate_operand" "0,m,r")))] - "TARGET_MOVBE && !(MEM_P (operands[0]) && MEM_P (operands[1]))" +(define_insn "*bswap2_movbe" + [(set (match_operand:SWI48 0 "nonimmediate_operand" "=r,r,m") + (bswap:SWI48 (match_operand:SWI48 1 "nonimmediate_operand" "0,m,r")))] + "TARGET_MOVBE + && !(MEM_P (operands[0]) && MEM_P (operands[1]))" "@ bswap\t%0 movbe\t{%1, %0|%0, %1} movbe\t{%1, %0|%0, %1}" - [(set_attr "type" "*,imov,imov") - (set_attr "modrm" "*,1,1") - (set_attr "prefix_0f" "1") + [(set_attr "type" "bitmanip,imov,imov") + (set_attr "modrm" "0,1,1") + (set_attr "prefix_0f" "*,1,1") (set_attr "prefix_extra" "*,1,1") - (set_attr "length" "2,*,*") - (set_attr "mode" "SI")]) + (set_attr "mode" "")]) -(define_insn "*bswapsi_1" - [(set (match_operand:SI 0 "register_operand" "=r") - (bswap:SI (match_operand:SI 1 "register_operand" "0")))] +(define_insn "*bswap2_1" + [(set (match_operand:SWI48 0 "register_operand" "=r") + (bswap:SWI48 (match_operand:SWI48 1 "register_operand" "0")))] "TARGET_BSWAP" "bswap\t%0" - [(set_attr "prefix_0f" "1") - (set_attr "length" "2")]) + [(set_attr "type" "bitmanip") + (set_attr "modrm" "0") + (set_attr "mode" "")]) (define_insn "*bswaphi_lowpart_1" [(set (strict_low_part (match_operand:HI 0 "register_operand" "+Q,r")) @@ -12444,114 +12435,6 @@ [(set_attr "length" "4") (set_attr "mode" "HI")]) -(define_expand "bswapdi2" - [(set (match_operand:DI 0 "register_operand" "") - (bswap:DI (match_operand:DI 1 "register_operand" "")))] - "TARGET_64BIT" - "") - -(define_insn "*bswapdi_movbe" - [(set (match_operand:DI 0 "nonimmediate_operand" "=r,r,m") - (bswap:DI (match_operand:DI 1 "nonimmediate_operand" "0,m,r")))] - "TARGET_64BIT && TARGET_MOVBE - && !(MEM_P (operands[0]) && MEM_P (operands[1]))" - "@ - bswap\t%0 - movbe\t{%1, %0|%0, %1} - movbe\t{%1, %0|%0, %1}" - [(set_attr "type" "*,imov,imov") - (set_attr "modrm" "*,1,1") - (set_attr "prefix_0f" "1") - (set_attr "prefix_extra" "*,1,1") - (set_attr "length" "3,*,*") - (set_attr "mode" "DI")]) - -(define_insn "*bswapdi_1" - [(set (match_operand:DI 0 "register_operand" "=r") - (bswap:DI (match_operand:DI 1 "register_operand" "0")))] - "TARGET_64BIT" - "bswap\t%0" - [(set_attr "prefix_0f" "1") - (set_attr "length" "3")]) - -(define_expand "clzdi2" - [(parallel - [(set (match_operand:DI 0 "register_operand" "") - (minus:DI (const_int 63) - (clz:DI (match_operand:DI 1 "nonimmediate_operand" "")))) - (clobber (reg:CC FLAGS_REG))]) - (parallel - [(set (match_dup 0) (xor:DI (match_dup 0) (const_int 63))) - (clobber (reg:CC FLAGS_REG))])] - "TARGET_64BIT" -{ - if (TARGET_ABM) - { - emit_insn (gen_clzdi2_abm (operands[0], operands[1])); - DONE; - } -}) - -(define_insn "clzdi2_abm" - [(set (match_operand:DI 0 "register_operand" "=r") - (clz:DI (match_operand:DI 1 "nonimmediate_operand" "rm"))) - (clobber (reg:CC FLAGS_REG))] - "TARGET_64BIT && TARGET_ABM" - "lzcnt{q}\t{%1, %0|%0, %1}" - [(set_attr "prefix_rep" "1") - (set_attr "type" "bitmanip") - (set_attr "mode" "DI")]) - -(define_insn "bsr_rex64" - [(set (match_operand:DI 0 "register_operand" "=r") - (minus:DI (const_int 63) - (clz:DI (match_operand:DI 1 "nonimmediate_operand" "rm")))) - (clobber (reg:CC FLAGS_REG))] - "TARGET_64BIT" - "bsr{q}\t{%1, %0|%0, %1}" - [(set_attr "type" "alu1") - (set_attr "prefix_0f" "1") - (set_attr "mode" "DI")]) - -(define_expand "clzhi2" - [(parallel - [(set (match_operand:HI 0 "register_operand" "") - (minus:HI (const_int 15) - (clz:HI (match_operand:HI 1 "nonimmediate_operand" "")))) - (clobber (reg:CC FLAGS_REG))]) - (parallel - [(set (match_dup 0) (xor:HI (match_dup 0) (const_int 15))) - (clobber (reg:CC FLAGS_REG))])] - "" -{ - if (TARGET_ABM) - { - emit_insn (gen_clzhi2_abm (operands[0], operands[1])); - DONE; - } -}) - -(define_insn "clzhi2_abm" - [(set (match_operand:HI 0 "register_operand" "=r") - (clz:HI (match_operand:HI 1 "nonimmediate_operand" "rm"))) - (clobber (reg:CC FLAGS_REG))] - "TARGET_ABM" - "lzcnt{w}\t{%1, %0|%0, %1}" - [(set_attr "prefix_rep" "1") - (set_attr "type" "bitmanip") - (set_attr "mode" "HI")]) - -(define_insn "*bsrhi" - [(set (match_operand:HI 0 "register_operand" "=r") - (minus:HI (const_int 15) - (clz:HI (match_operand:HI 1 "nonimmediate_operand" "rm")))) - (clobber (reg:CC FLAGS_REG))] - "" - "bsr{w}\t{%1, %0|%0, %1}" - [(set_attr "type" "alu1") - (set_attr "prefix_0f" "1") - (set_attr "mode" "HI")]) - (define_expand "paritydi2" [(set (match_operand:DI 0 "register_operand" "") (parity:DI (match_operand:DI 1 "register_operand" "")))] @@ -12580,6 +12463,25 @@ DONE; }) +(define_expand "paritysi2" + [(set (match_operand:SI 0 "register_operand" "") + (parity:SI (match_operand:SI 1 "register_operand" "")))] + "! TARGET_POPCNT" +{ + rtx scratch = gen_reg_rtx (QImode); + rtx cond; + + emit_insn (gen_paritysi2_cmp (NULL_RTX, NULL_RTX, operands[1])); + + cond = gen_rtx_fmt_ee (ORDERED, QImode, + gen_rtx_REG (CCmode, FLAGS_REG), + const0_rtx); + emit_insn (gen_rtx_SET (VOIDmode, scratch, cond)); + + emit_insn (gen_zero_extendqisi2 (operands[0], scratch)); + DONE; +}) + (define_insn_and_split "paritydi2_cmp" [(set (reg:CC FLAGS_REG) (parity:CC (match_operand:DI 3 "register_operand" "0"))) @@ -12610,25 +12512,6 @@ operands[1] = gen_highpart (SImode, operands[3]); }) -(define_expand "paritysi2" - [(set (match_operand:SI 0 "register_operand" "") - (parity:SI (match_operand:SI 1 "register_operand" "")))] - "! TARGET_POPCNT" -{ - rtx scratch = gen_reg_rtx (QImode); - rtx cond; - - emit_insn (gen_paritysi2_cmp (NULL_RTX, NULL_RTX, operands[1])); - - cond = gen_rtx_fmt_ee (ORDERED, QImode, - gen_rtx_REG (CCmode, FLAGS_REG), - const0_rtx); - emit_insn (gen_rtx_SET (VOIDmode, scratch, cond)); - - emit_insn (gen_zero_extendqisi2 (operands[0], scratch)); - DONE; -}) - (define_insn_and_split "paritysi2_cmp" [(set (reg:CC FLAGS_REG) (parity:CC (match_operand:SI 2 "register_operand" "0"))) @@ -16783,8 +16666,10 @@ (if_then_else:SI (match_op_dup 1 [(match_dup 4) (const_int 0)]) (match_dup 7) (match_dup 8)))] - "split_di (&operands[2], 2, &operands[5], &operands[7]); - split_di (&operands[0], 1, &operands[2], &operands[3]);") +{ + split_di (&operands[2], 2, &operands[5], &operands[7]); + split_di (&operands[0], 1, &operands[2], &operands[3]); +}) (define_insn "*movxfcc_1" [(set (match_operand:XF 0 "register_operand" "=f,f") @@ -18441,15 +18326,24 @@ (reg:DI XMM5_REG) (reg:DI XMM6_REG) (reg:DI XMM7_REG)] UNSPEC_SSE_PROLOGUE_SAVE)) - (use (match_operand:DI 1 "register_operand" "")) + (clobber (match_operand:DI 1 "register_operand" "")) (use (match_operand:DI 2 "immediate_operand" "")) - (use (label_ref:DI (match_operand 3 "" "")))])] + (use (label_ref:DI (match_operand 3 "" ""))) + (clobber (match_operand:DI 4 "register_operand" "")) + (use (match_dup 1))])] "TARGET_64BIT" "") -(define_insn "*sse_prologue_save_insn" +;; Pre-reload version of prologue save. Until after prologue generation we don't know +;; what the size of save instruction will be. +;; Operand 0+operand 6 is the memory save area +;; Operand 1 is number of registers to save (will get overwritten to operand 5) +;; Operand 2 is number of non-vaargs SSE arguments +;; Operand 3 is label starting the save block +;; Operand 4 is used for temporary computation of jump address +(define_insn "*sse_prologue_save_insn1" [(set (mem:BLK (plus:DI (match_operand:DI 0 "register_operand" "R") - (match_operand:DI 4 "const_int_operand" "n"))) + (match_operand:DI 6 "const_int_operand" "n"))) (unspec:BLK [(reg:DI XMM0_REG) (reg:DI XMM1_REG) (reg:DI XMM2_REG) @@ -18458,9 +18352,98 @@ (reg:DI XMM5_REG) (reg:DI XMM6_REG) (reg:DI XMM7_REG)] UNSPEC_SSE_PROLOGUE_SAVE)) + (clobber (match_operand:DI 1 "register_operand" "=r")) + (use (match_operand:DI 2 "const_int_operand" "i")) + (use (label_ref:DI (match_operand 3 "" "X"))) + (clobber (match_operand:DI 4 "register_operand" "=&r")) + (use (match_operand:DI 5 "register_operand" "1"))] + "TARGET_64BIT + && INTVAL (operands[6]) + X86_64_SSE_REGPARM_MAX * 16 - 16 < 128 + && INTVAL (operands[6]) + INTVAL (operands[2]) * 16 >= -128" + "#" + [(set_attr "type" "other") + (set_attr "memory" "store") + (set_attr "mode" "DI")]) + +;; We know size of save instruction; expand the computation of jump address +;; in the jumptable. +(define_split + [(parallel [(set (match_operand:BLK 0 "" "") + (unspec:BLK [(reg:DI XMM0_REG) + (reg:DI XMM1_REG) + (reg:DI XMM2_REG) + (reg:DI XMM3_REG) + (reg:DI XMM4_REG) + (reg:DI XMM5_REG) + (reg:DI XMM6_REG) + (reg:DI XMM7_REG)] UNSPEC_SSE_PROLOGUE_SAVE)) + (clobber (match_operand:DI 1 "register_operand" "")) + (use (match_operand:DI 2 "const_int_operand" "")) + (use (match_operand 3 "" "")) + (clobber (match_operand:DI 4 "register_operand" "")) + (use (match_operand:DI 5 "register_operand" ""))])] + "reload_completed" + [(parallel [(set (match_dup 0) + (unspec:BLK [(reg:DI XMM0_REG) + (reg:DI XMM1_REG) + (reg:DI XMM2_REG) + (reg:DI XMM3_REG) + (reg:DI XMM4_REG) + (reg:DI XMM5_REG) + (reg:DI XMM6_REG) + (reg:DI XMM7_REG)] UNSPEC_SSE_PROLOGUE_SAVE_LOW)) + (use (match_dup 1)) + (use (match_dup 2)) + (use (match_dup 3)) + (use (match_dup 5))])] +{ + /* Movaps is 4 bytes, AVX and movsd is 5 bytes. */ + int size = 4 + (TARGET_AVX || crtl->stack_alignment_needed < 128); + + /* Compute address to jump to: + label - eax*size + nnamed_sse_arguments*size. */ + if (size == 5) + emit_insn (gen_rtx_SET (VOIDmode, operands[4], + gen_rtx_PLUS + (Pmode, + gen_rtx_MULT (Pmode, operands[1], + GEN_INT (4)), + operands[1]))); + else if (size == 4) + emit_insn (gen_rtx_SET (VOIDmode, operands[4], + gen_rtx_MULT (Pmode, operands[1], + GEN_INT (4)))); + else + gcc_unreachable (); + if (INTVAL (operands[2])) + emit_move_insn + (operands[1], + gen_rtx_CONST (DImode, + gen_rtx_PLUS (DImode, + operands[3], + GEN_INT (INTVAL (operands[2]) + * size)))); + else + emit_move_insn (operands[1], operands[3]); + emit_insn (gen_subdi3 (operands[1], operands[1], operands[4])); + operands[5] = GEN_INT (size); +}) + +(define_insn "sse_prologue_save_insn" + [(set (mem:BLK (plus:DI (match_operand:DI 0 "register_operand" "R") + (match_operand:DI 4 "const_int_operand" "n"))) + (unspec:BLK [(reg:DI XMM0_REG) + (reg:DI XMM1_REG) + (reg:DI XMM2_REG) + (reg:DI XMM3_REG) + (reg:DI XMM4_REG) + (reg:DI XMM5_REG) + (reg:DI XMM6_REG) + (reg:DI XMM7_REG)] UNSPEC_SSE_PROLOGUE_SAVE_LOW)) (use (match_operand:DI 1 "register_operand" "r")) (use (match_operand:DI 2 "const_int_operand" "i")) - (use (label_ref:DI (match_operand 3 "" "X")))] + (use (label_ref:DI (match_operand 3 "" "X"))) + (use (match_operand:DI 5 "const_int_operand" "i"))] "TARGET_64BIT && INTVAL (operands[4]) + X86_64_SSE_REGPARM_MAX * 16 - 16 < 128 && INTVAL (operands[4]) + INTVAL (operands[2]) * 16 >= -128" @@ -18480,7 +18463,10 @@ PUT_MODE (operands[4], TImode); if (GET_CODE (XEXP (operands[0], 0)) != PLUS) output_asm_insn ("rex", operands); - output_asm_insn ("%vmovaps\t{%5, %4|%4, %5}", operands); + if (crtl->stack_alignment_needed < 128) + output_asm_insn ("%vmovsd\t{%5, %4|%4, %5}", operands); + else + output_asm_insn ("%vmovaps\t{%5, %4|%4, %5}", operands); } (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (operands[3])); @@ -18489,11 +18475,11 @@ [(set_attr "type" "other") (set_attr "length_immediate" "0") (set_attr "length_address" "0") + ;; 2 bytes for jump and opernds[4] bytes for each save. (set (attr "length") - (if_then_else - (eq (symbol_ref "TARGET_AVX") (const_int 0)) - (const_string "34") - (const_string "42"))) + (plus (const_int 2) + (mult (symbol_ref ("INTVAL (operands[5])")) + (symbol_ref ("X86_64_SSE_REGPARM_MAX - INTVAL (operands[2])"))))) (set_attr "memory" "store") (set_attr "modrm" "0") (set_attr "prefix" "maybe_vex") diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c index dc6ca524e60..983ecf40372 100644 --- a/gcc/config/ia64/ia64.c +++ b/gcc/config/ia64/ia64.c @@ -537,6 +537,9 @@ static const struct attribute_spec ia64_attribute_table[] = #undef TARGET_TRAMPOLINE_INIT #define TARGET_TRAMPOLINE_INIT ia64_trampoline_init +#undef TARGET_INVALID_WITHIN_DOLOOP +#define TARGET_INVALID_WITHIN_DOLOOP hook_constcharptr_const_rtx_null + #undef TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE #define TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE ia64_override_options_after_change diff --git a/gcc/config/ia64/ia64.h b/gcc/config/ia64/ia64.h index 53bbda2b1ed..c019aa48184 100644 --- a/gcc/config/ia64/ia64.h +++ b/gcc/config/ia64/ia64.h @@ -416,7 +416,7 @@ while (0) /* Branch registers. */ \ 0, 0, 0, 0, 0, 0, 0, 0, \ /*FP CCV UNAT PFS LC EC */ \ - 1, 1, 1, 1, 0, 1 \ + 1, 1, 1, 1, 1, 1 \ } /* Like `FIXED_REGISTERS' but has 1 for each register that is clobbered @@ -451,7 +451,7 @@ while (0) /* Branch registers. */ \ 1, 0, 0, 0, 0, 0, 1, 1, \ /*FP CCV UNAT PFS LC EC */ \ - 1, 1, 1, 1, 0, 1 \ + 1, 1, 1, 1, 1, 1 \ } /* Like `CALL_USED_REGISTERS' but used to overcome a historical diff --git a/gcc/config/rs6000/x-aix b/gcc/config/rs6000/x-aix index 11ccb932d4b..d40690f2da6 100644 --- a/gcc/config/rs6000/x-aix +++ b/gcc/config/rs6000/x-aix @@ -2,5 +2,5 @@ build/genautomata : override LDFLAGS += -Wl,-bmaxdata:0x20000000 # jc1 requires more than 256MB of data -jc1 : override LDFLAGS += -Wl,-bmaxdata:0x20000000 +$(COMPILERS) : override LDFLAGS += -Wl,-bmaxdata:0x40000000 diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c index c3820e58012..858aac9f084 100644 --- a/gcc/config/s390/s390.c +++ b/gcc/config/s390/s390.c @@ -9539,11 +9539,25 @@ s390_emit_call (rtx addr_location, rtx tls_call, rtx result_reg, replace the symbol itself with the PLT stub. */ if (flag_pic && !SYMBOL_REF_LOCAL_P (addr_location)) { - addr_location = gen_rtx_UNSPEC (Pmode, - gen_rtvec (1, addr_location), - UNSPEC_PLT); - addr_location = gen_rtx_CONST (Pmode, addr_location); - plt_call = true; + if (retaddr_reg != NULL_RTX) + { + addr_location = gen_rtx_UNSPEC (Pmode, + gen_rtvec (1, addr_location), + UNSPEC_PLT); + addr_location = gen_rtx_CONST (Pmode, addr_location); + plt_call = true; + } + else + /* For -fpic code the PLT entries might use r12 which is + call-saved. Therefore we cannot do a sibcall when + calling directly using a symbol ref. When reaching + this point we decided (in s390_function_ok_for_sibcall) + to do a sibcall for a function pointer but one of the + optimizers was able to get rid of the function pointer + by propagating the symbol ref into the call. This + optimization is illegal for S/390 so we turn the direct + call into a indirect call again. */ + addr_location = force_reg (Pmode, addr_location); } /* Unless we can use the bras(l) insn, force the diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c index 04b98c1eb22..a3084b91a0b 100644 --- a/gcc/config/sh/sh.c +++ b/gcc/config/sh/sh.c @@ -4410,6 +4410,7 @@ find_barrier (int num_mova, rtx mova, rtx from) int hi_limit; rtx orig = from; rtx last_got = NULL_RTX; + rtx last_symoff = NULL_RTX; /* For HImode: range is 510, add 4 because pc counts from address of second instruction after this one, subtract 2 for the jump instruction @@ -4551,6 +4552,16 @@ find_barrier (int num_mova, rtx mova, rtx from) { switch (untangle_mova (&num_mova, &mova, from)) { + case 1: + if (flag_pic) + { + rtx src = SET_SRC (PATTERN (from)); + if (GET_CODE (src) == CONST + && GET_CODE (XEXP (src, 0)) == UNSPEC + && XINT (XEXP (src, 0), 1) == UNSPEC_SYMOFF) + last_symoff = from; + } + break; case 0: return find_barrier (0, 0, mova); case 2: { @@ -4654,6 +4665,12 @@ find_barrier (int num_mova, rtx mova, rtx from) so we'll make one. */ rtx label = gen_label_rtx (); + /* Don't emit a constant table in the middle of insns for + casesi_worker_2. This is a bit overkill but is enough + because casesi_worker_2 wouldn't appear so frequently. */ + if (last_symoff) + from = last_symoff; + /* If we exceeded the range, then we must back up over the last instruction we looked at. Otherwise, we just need to undo the NEXT_INSN at the end of the loop. */ diff --git a/gcc/config/stormy16/stormy16-lib2-ucmpsi2.c b/gcc/config/stormy16/stormy16-lib2-ucmpsi2.c new file mode 100644 index 00000000000..da1a3e70753 --- /dev/null +++ b/gcc/config/stormy16/stormy16-lib2-ucmpsi2.c @@ -0,0 +1,2 @@ +#define XSTORMY16_UCMPSI2 +#include "stormy16-lib2.c" diff --git a/gcc/config/stormy16/stormy16-lib2.c b/gcc/config/stormy16/stormy16-lib2.c index 0c99cdd3e90..edf8635e192 100644 --- a/gcc/config/stormy16/stormy16-lib2.c +++ b/gcc/config/stormy16/stormy16-lib2.c @@ -4,7 +4,7 @@ files. On this glorious day maybe this code can be integrated into it too. */ -/* Copyright (C) 2005, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 2005, 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GCC. @@ -309,3 +309,26 @@ __ffshi2 (UHWtype u) return 16 - __builtin_clz (u & - u); } #endif + +#ifdef XSTORMY16_UCMPSI2 +/* Performs an unsigned comparison of two 32-bit values: A and B. + If A is less than B, then 0 is returned. If A is greater than B, + then 2 is returned. Otherwise A and B are equal and 1 is returned. */ + +word_type +__ucmpsi2 (USItype a, USItype b) +{ + word_type hi_a = (a >> 16); + word_type hi_b = (b >> 16); + + if (hi_a == hi_b) + { + word_type low_a = (a & 0xffff); + word_type low_b = (b & 0xffff); + + return low_a < low_b ? 0 : (low_a > low_b ? 2 : 1); + } + + return hi_a < hi_b ? 0 : 2; +} +#endif diff --git a/gcc/config/stormy16/stormy16.c b/gcc/config/stormy16/stormy16.c index 03e716f096e..c3627ca6e96 100644 --- a/gcc/config/stormy16/stormy16.c +++ b/gcc/config/stormy16/stormy16.c @@ -1561,7 +1561,7 @@ xstormy16_asm_output_aligned_common (FILE *stream, int align, int global) { - rtx mem = DECL_RTL (decl); + rtx mem = decl == NULL_TREE ? NULL_RTX : DECL_RTL (decl); rtx symbol; if (mem != NULL_RTX diff --git a/gcc/config/stormy16/stormy16.h b/gcc/config/stormy16/stormy16.h index fa97e8becdc..cf6acf586c2 100644 --- a/gcc/config/stormy16/stormy16.h +++ b/gcc/config/stormy16/stormy16.h @@ -1,29 +1,28 @@ /* Xstormy16 cpu description. Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, - 2008, 2009 Free Software Foundation, Inc. + 2008, 2009, 2010 Free Software Foundation, Inc. Contributed by Red Hat, Inc. -This file is part of GCC. + 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 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. + 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 -. */ + You should have received a copy of the GNU General Public License + along with GCC; see the file COPYING3. If not see + . */ -/* Driver configuration */ +/* Driver configuration. */ -/* Defined in svr4.h. */ -#undef ASM_SPEC +#undef ASM_SPEC #define ASM_SPEC "" /* For xstormy16: @@ -31,41 +30,33 @@ along with GCC; see the file COPYING3. If not see - If -T is specified, that linker script is used, and it should provide appropriate libraries. - If neither is specified, everything is built as for the sim, but no - I/O support is assumed. - -*/ -#undef LIB_SPEC + I/O support is assumed. */ +#undef LIB_SPEC #define LIB_SPEC "-( -lc %{msim:-lsim}%{!msim:%{!T*:-lnosys}} -)" -/* Defined in svr4.h. */ -#undef STARTFILE_SPEC +#undef STARTFILE_SPEC #define STARTFILE_SPEC "crt0.o%s crti.o%s crtbegin.o%s" -/* Defined in svr4.h. */ -#undef ENDFILE_SPEC +#undef ENDFILE_SPEC #define ENDFILE_SPEC "crtend.o%s crtn.o%s" -/* Defined in svr4.h for host compilers. */ -/* #define MD_EXEC_PREFIX "" */ - -/* Defined in svr4.h for host compilers. */ -/* #define MD_STARTFILE_PREFIX "" */ - -/* Run-time target specifications */ +/* Run-time target specifications. */ -#define TARGET_CPU_CPP_BUILTINS() do { \ - builtin_define_std ("xstormy16"); \ - builtin_assert ("machine=xstormy16"); \ - builtin_assert ("cpu=xstormy16"); \ -} while (0) +#define TARGET_CPU_CPP_BUILTINS() \ + do \ + { \ + builtin_define_std ("xstormy16"); \ + builtin_assert ("machine=xstormy16"); \ + builtin_assert ("cpu=xstormy16"); \ + } \ + while (0) #define TARGET_VERSION fprintf (stderr, " (xstormy16 cpu core)"); #define CAN_DEBUG_WITHOUT_FP - -/* Storage Layout */ +/* Storage Layout. */ #define BITS_BIG_ENDIAN 1 @@ -75,12 +66,14 @@ along with GCC; see the file COPYING3. If not see #define UNITS_PER_WORD 2 -#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \ -do { \ - if (GET_MODE_CLASS (MODE) == MODE_INT \ - && GET_MODE_SIZE (MODE) < 2) \ - (MODE) = HImode; \ -} while (0) +#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \ + do \ + { \ + if (GET_MODE_CLASS (MODE) == MODE_INT \ + && GET_MODE_SIZE (MODE) < 2) \ + (MODE) = HImode; \ + } \ + while (0) #define PARM_BOUNDARY 16 @@ -90,9 +83,6 @@ do { \ #define BIGGEST_ALIGNMENT 16 -/* Defined in svr4.h. */ -/* #define MAX_OFILE_ALIGNMENT */ - #define DATA_ALIGNMENT(TYPE, ALIGN) \ (TREE_CODE (TYPE) == ARRAY_TYPE \ && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \ @@ -104,10 +94,9 @@ do { \ #define STRICT_ALIGNMENT 1 -/* Defined in svr4.h. */ #define PCC_BITFIELD_TYPE_MATTERS 1 -/* Layout of Source Language Data Types */ +/* Layout of Source Language Data Types. */ #define INT_TYPE_SIZE 16 @@ -125,27 +114,15 @@ do { \ #define DEFAULT_SIGNED_CHAR 0 -/* Defined in svr4.h. */ #define SIZE_TYPE "unsigned int" -/* Defined in svr4.h. */ #define PTRDIFF_TYPE "int" -/* Defined in svr4.h, to "long int". */ -/* #define WCHAR_TYPE "long int" */ - -/* Defined in svr4.h. */ -#undef WCHAR_TYPE_SIZE +#undef WCHAR_TYPE_SIZE #define WCHAR_TYPE_SIZE 32 -/* Define this macro if the type of Objective-C selectors should be `int'. - - If this macro is not defined, then selectors should have the type `struct - objc_selector *'. */ -/* #define OBJC_INT_SELECTORS */ - -/* Register Basics */ +/* Register Basics. */ #define FIRST_PSEUDO_REGISTER 19 @@ -156,12 +133,12 @@ do { \ { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1 } -/* Order of allocation of registers */ +/* Order of allocation of registers. */ #define REG_ALLOC_ORDER { 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 10, 11, 12, 13, 14, 15, 16 } -/* How Values Fit in Registers */ +/* How Values Fit in Registers. */ #define HARD_REGNO_NREGS(REGNO, MODE) \ ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) @@ -178,7 +155,7 @@ do { \ #define MODES_TIEABLE_P(MODE1, MODE2) ((MODE1) != BImode && (MODE2) != BImode) -/* Register Classes */ +/* Register Classes. */ enum reg_class { @@ -199,7 +176,7 @@ enum reg_class #define IRA_COVER_CLASSES \ { \ - GENERAL_REGS, LIM_REG_CLASSES \ + GENERAL_REGS, LIM_REG_CLASSES \ } #define REG_CLASS_NAMES \ @@ -251,7 +228,7 @@ enum reg_class 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P' 'Q', 'R', 'S', 'T', 'U' 'V', 'X' - 'g', 'i', 'm', 'n', 'o', 'p', 'r', 's' */ + 'g', 'i', 'm', 'n', 'o', 'p', 'r', 's'. */ #define REG_CLASS_FROM_LETTER(CHAR) \ ( (CHAR) == 'a' ? R0_REGS \ @@ -267,7 +244,6 @@ enum reg_class #define REGNO_OK_FOR_INDEX_P(NUM) REGNO_OK_FOR_BASE_P (NUM) -/* This declaration must be present. */ #define PREFERRED_RELOAD_CLASS(X, CLASS) \ xstormy16_preferred_reload_class (X, CLASS) @@ -279,40 +255,9 @@ enum reg_class #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \ xstormy16_secondary_reload_class (CLASS, MODE, X) -/* Normally the compiler avoids choosing registers that have been explicitly - mentioned in the rtl as spill registers (these registers are normally those - used to pass parameters and return values). However, some machines have so - few registers of certain classes that there would not be enough registers to - use as spill registers if this were done. - - Define `SMALL_REGISTER_CLASSES' to be an expression with a nonzero value on - these machines. When this macro has a nonzero value, the compiler allows - registers explicitly used in the rtl to be used as spill registers but - avoids extending the lifetime of these registers. - - It is always safe to define this macro with a nonzero value, but if you - unnecessarily define it, you will reduce the amount of optimizations that - can be performed in some cases. If you do not define this macro with a - nonzero value when it is required, the compiler will run out of spill - registers and print a fatal error message. For most machines, you should - not define this macro at all. */ -/* #define SMALL_REGISTER_CLASSES */ - -/* This declaration is required. */ #define CLASS_MAX_NREGS(CLASS, MODE) \ ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) -/* If defined, a C expression for a class that contains registers which the - compiler must always access in a mode that is the same size as the mode in - which it loaded the register. - - For the example, loading 32-bit integer or floating-point objects into - floating-point registers on the Alpha extends them to 64-bits. Therefore - loading a 64-bit object and then storing it as a 32-bit object does not - store the low-order 32-bits, as would be the case for a normal register. - Therefore, `alpha.h' defines this macro as `FLOAT_REGS'. */ -/* #define CLASS_CANNOT_CHANGE_SIZE */ - #define CONST_OK_FOR_LETTER_P(VALUE, C) \ ( (C) == 'I' ? (VALUE) >= 0 && (VALUE) <= 3 \ : (C) == 'J' ? exact_log2 (VALUE) != -1 \ @@ -330,7 +275,7 @@ enum reg_class xstormy16_extra_constraint_p (VALUE, C) -/* Basic Stack Layout */ +/* Basic Stack Layout. */ /* We want to use post-increment instructions to push things on the stack, because we don't have any pre-increment ones. */ @@ -365,7 +310,7 @@ enum reg_class #define ARG_POINTER_REGNUM 18 -/* Eliminating the Frame Pointer and the Arg Pointer */ +/* Eliminating the Frame Pointer and the Arg Pointer. */ #define ELIMINABLE_REGS \ { \ @@ -379,16 +324,16 @@ enum reg_class (OFFSET) = xstormy16_initial_elimination_offset (FROM, TO) -/* Passing Function Arguments on the Stack */ +/* Passing Function Arguments on the Stack. */ #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1) #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0 -/* Function Arguments in Registers */ +/* Function Arguments in Registers. */ -#define NUM_ARGUMENT_REGISTERS 6 +#define NUM_ARGUMENT_REGISTERS 6 #define FIRST_ARGUMENT_REGISTER 2 #define XSTORMY16_WORD_SIZE(TYPE, MODE) \ @@ -414,7 +359,7 @@ enum reg_class && (REGNO) < FIRST_ARGUMENT_REGISTER + NUM_ARGUMENT_REGISTERS) -/* How Scalar Function Values are Returned */ +/* How Scalar Function Values are Returned. */ /* The number of the hard register that is used to return a scalar value from a function call. */ @@ -428,7 +373,7 @@ enum reg_class #define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == RETURN_VALUE_REGNUM) -/* Function Entry and Exit */ +/* Function Entry and Exit. */ #define EPILOGUE_USES(REGNO) \ xstormy16_epilogue_uses (REGNO) @@ -442,81 +387,13 @@ enum reg_class #define FUNCTION_PROFILER(FILE, LABELNO) xstormy16_function_profiler () -/* If the target has particular reasons why a function cannot be inlined, - it may define the TARGET_CANNOT_INLINE_P. This macro takes one argument, - the DECL describing the function. The function should NULL if the function - *can* be inlined. Otherwise it should return a pointer to a string containing - a message describing why the function could not be inlined. The message will - displayed if the '-Winline' command line switch has been given. If the message - contains a '%s' sequence, this will be replaced by the name of the function. */ -/* #define TARGET_CANNOT_INLINE_P(FN_DECL) xstormy16_cannot_inline_p (FN_DECL) */ - /* Trampolines for Nested Functions. */ #define TRAMPOLINE_SIZE 8 #define TRAMPOLINE_ALIGNMENT 16 -/* Define this macro to override the type used by the library routines to pick - up arguments of type `float'. (By default, they use a union of `float' and - `int'.) - - The obvious choice would be `float'--but that won't work with traditional C - compilers that expect all arguments declared as `float' to arrive as - `double'. To avoid this conversion, the library routines ask for the value - as some other type and then treat it as a `float'. */ -/* #define FLOAT_ARG_TYPE */ - -/* Define this macro to override the way library routines redesignate a `float' - argument as a `float' instead of the type it was passed as. The default is - an expression which takes the `float' field of the union. */ -/* #define FLOATIFY(PASSED_VALUE) */ - -/* Define this macro to override the type used by the library routines to - return values that ought to have type `float'. (By default, they use - `int'.) - - The obvious choice would be `float'--but that won't work with traditional C - compilers gratuitously convert values declared as `float' into `double'. */ -/* #define FLOAT_VALUE_TYPE */ - -/* Define this macro to override the way the value of a `float'-returning - library routine should be packaged in order to return it. These functions - are actually declared to return type `FLOAT_VALUE_TYPE' (normally `int'). - - These values can't be returned as type `float' because traditional C - compilers would gratuitously convert the value to a `double'. - - A local variable named `intify' is always available when the macro `INTIFY' - is used. It is a union of a `float' field named `f' and a field named `i' - whose type is `FLOAT_VALUE_TYPE' or `int'. - If you don't define this macro, the default definition works by copying the - value through that union. */ -/* #define INTIFY(FLOAT_VALUE) */ - -/* Define this macro as the name of the data type corresponding to `SImode' in - the system's own C compiler. - - You need not define this macro if that type is `long int', as it usually is. */ -/* #define nongcc_SI_type */ - -/* Define this macro as the name of the data type corresponding to the - word_mode in the system's own C compiler. - - You need not define this macro if that type is `long int', as it usually is. */ -/* #define nongcc_word_type */ - -/* Define these macros to supply explicit C statements to carry out various - arithmetic operations on types `float' and `double' in the library routines - in `libgcc1.c'. See that file for a full list of these macros and their - arguments. - - On most machines, you don't need to define any of these macros, because the - C compiler that comes with the system takes care of doing them. */ -/* #define perform_... */ - - -/* Addressing Modes */ +/* Addressing Modes. */ #define HAVE_POST_INCREMENT 1 @@ -536,16 +413,15 @@ enum reg_class /* On this chip, this is true if the address is valid with an offset of 0 but not of 6, because in that case it cannot be used as an address for DImode or DFmode, or if the address is a post-increment - or pre-decrement address. -*/ + or pre-decrement address. */ #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \ - if (xstormy16_mode_dependent_address_p (ADDR)) \ + if (xstormy16_mode_dependent_address_p (ADDR)) \ goto LABEL #define LEGITIMATE_CONSTANT_P(X) 1 -/* Describing Relative Costs of Operations */ +/* Describing Relative Costs of Operations. */ #define REGISTER_MOVE_COST(MODE, FROM, TO) 2 @@ -602,64 +478,31 @@ enum reg_class /* Output and Generation of Labels. */ #define SYMBOL_FLAG_XSTORMY16_BELOW100 (SYMBOL_FLAG_MACH_DEP << 0) -#define ASM_OUTPUT_SYMBOL_REF(STREAM, SYMBOL) \ - do { \ - const char *rn = XSTR (SYMBOL, 0); \ - if (SYMBOL_REF_FUNCTION_P (SYMBOL)) \ - ASM_OUTPUT_LABEL_REF ((STREAM), rn); \ - else \ - assemble_name (STREAM, rn); \ - } while (0) +#define ASM_OUTPUT_SYMBOL_REF(STREAM, SYMBOL) \ + do \ + { \ + const char *rn = XSTR (SYMBOL, 0); \ + \ + if (SYMBOL_REF_FUNCTION_P (SYMBOL)) \ + ASM_OUTPUT_LABEL_REF ((STREAM), rn); \ + else \ + assemble_name (STREAM, rn); \ + } \ + while (0) #define ASM_OUTPUT_LABEL_REF(STREAM, NAME) \ -do { \ - fputs ("@fptr(", STREAM); \ - assemble_name (STREAM, NAME); \ - fputc (')', STREAM); \ -} while (0) + do \ + { \ + fputs ("@fptr(", STREAM); \ + assemble_name (STREAM, NAME); \ + fputc (')', STREAM); \ + } \ + while (0) /* Globalizing directive for a label. */ #define GLOBAL_ASM_OP "\t.globl " -/* Macros Controlling Initialization Routines. */ - -/* When you are using special sections for - initialization and termination functions, this macro also controls how - `crtstuff.c' and `libgcc2.c' arrange to run the initialization functions. - - Defined in svr4.h. */ -/* #define INIT_SECTION_ASM_OP */ - -/* Define this macro as a C statement to output on the stream STREAM the - assembler code to arrange to call the function named NAME at initialization - time. - - Assume that NAME is the name of a C function generated automatically by the - compiler. This function takes no arguments. Use the function - `assemble_name' to output the name NAME; this performs any system-specific - syntactic transformations such as adding an underscore. - - If you don't define this macro, nothing special is output to arrange to call - the function. This is correct when the function will be called in some - other manner--for example, by means of the `collect2' program, which looks - through the symbol table to find these functions by their names. - - Defined in svr4.h. */ -/* #define ASM_OUTPUT_CONSTRUCTOR(STREAM, NAME) */ - -/* This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination functions - rather than initialization functions. - - Defined in svr4.h. */ -/* #define ASM_OUTPUT_DESTRUCTOR(STREAM, NAME) */ - -/* Define this macro if the system uses ELF format object files. - - Defined in svr4.h. */ -/* #define OBJECT_FORMAT_ELF */ - - /* Output of Assembler Instructions. */ #define REGISTER_NAMES \ @@ -705,9 +548,7 @@ do { \ #define DWARF2_UNWIND_INFO 0 #define DWARF_CIE_DATA_ALIGNMENT 1 -/* Don't use __builtin_setjmp for unwinding, since it's tricky to get - at the high 16 bits of an address. */ -#define DONT_USE_BUILTIN_SETJMP +#undef DONT_USE_BUILTIN_SETJMP #define JMP_BUF_SIZE 8 /* Assembler Commands for Alignment. */ @@ -719,7 +560,7 @@ do { \ /* Macros Affecting all Debug Formats. */ /* Defined in svr4.h. */ -#undef PREFERRED_DEBUGGING_TYPE +#undef PREFERRED_DEBUGGING_TYPE #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG @@ -757,22 +598,4 @@ do { \ #define NO_IMPLICIT_EXTERN_C -/* Defined in svr4.h. */ #define HANDLE_SYSV_PRAGMA 1 - -/* Define this if the target system supports the function `atexit' from the - ANSI C standard. If this is not defined, and `INIT_SECTION_ASM_OP' is not - defined, a default `exit' function will be provided to support C++. - - Defined by svr4.h */ -/* #define HAVE_ATEXIT */ - -/* A C statement which is executed by the Haifa scheduler after it has scheduled - an insn from the ready list. FILE is either a null pointer, or a stdio stream - to write any debug output to. VERBOSE is the verbose level provided by - -fsched-verbose-. INSN is the instruction that was scheduled. MORE is the - number of instructions that can be issued in the current cycle. This macro - is responsible for updating the value of MORE (typically by (MORE)--). */ -/* #define MD_SCHED_VARIABLE_ISSUE (FILE, VERBOSE, INSN, MORE) */ - -/* End of xstormy16.h */ diff --git a/gcc/config/stormy16/stormy16.md b/gcc/config/stormy16/stormy16.md index 9c86d43e627..d8113420aba 100644 --- a/gcc/config/stormy16/stormy16.md +++ b/gcc/config/stormy16/stormy16.md @@ -759,21 +759,6 @@ DONE; }) -(define_expand "cbranchsi4" - [(set (pc) - (if_then_else (match_operator 0 "comparison_operator" - [(match_operand:SI 1 "register_operand" "") - (match_operand:SI 2 "nonmemory_operand" "")]) - (label_ref (match_operand 3 "" "")) - (pc))) - (clobber (reg:BI CARRY_REG))] - "" - { - xstormy16_emit_cbranch (GET_CODE (operands[0]), operands[1], operands[2], - operands[3]); - DONE; -}) - (define_insn "cbranchhi" [(set (pc) (if_then_else (match_operator:HI 1 "comparison_operator" @@ -827,24 +812,6 @@ [(set_attr "branch_class" "bcc8p2") (set_attr "psw_operand" "clobber")]) -(define_insn_and_split "*ineqbranchsi" - [(set (pc) - (if_then_else (match_operator:SI 1 "xstormy16_ineqsi_operator" - [(match_operand:SI 2 "register_operand" - "r") - (match_operand:SI 3 "nonmemory_operand" - "ri")]) - (label_ref (match_operand 0 "" "")) - (pc))) - (clobber (match_operand:SI 4 "register_operand" "=2")) - (clobber (reg:BI CARRY_REG))] - "" - "#" - "reload_completed" - [(pc)] - { xstormy16_split_cbranch (SImode, operands[0], operands[1], operands[2]); DONE; } - [(set_attr "length" "8")]) - (define_insn "*ineqbranch_1" [(set (pc) (if_then_else (match_operator:HI 4 "xstormy16_ineqsi_operator" diff --git a/gcc/config/stormy16/t-stormy16 b/gcc/config/stormy16/t-stormy16 index 8959e64ab5e..7ca26356cb7 100644 --- a/gcc/config/stormy16/t-stormy16 +++ b/gcc/config/stormy16/t-stormy16 @@ -1,6 +1,6 @@ # -*- makefile -*- # -# Copyright (C) 2001, 2004 Free Software Foundation, Inc. +# Copyright (C) 2001, 2004, 2010 Free Software Foundation, Inc. # # This file is part of GCC. # @@ -32,7 +32,8 @@ LIB2FUNCS_EXTRA = \ $(srcdir)/config/stormy16/stormy16-lib2-parityhi2.c \ $(srcdir)/config/stormy16/stormy16-lib2-clzhi2.c \ $(srcdir)/config/stormy16/stormy16-lib2-ctzhi2.c \ - $(srcdir)/config/stormy16/stormy16-lib2-ffshi2.c + $(srcdir)/config/stormy16/stormy16-lib2-ffshi2.c \ + $(srcdir)/config/stormy16/stormy16-lib2-ucmpsi2.c # Floating point emulation libraries. FPBIT = fp-bit.c diff --git a/gcc/configure b/gcc/configure index de9cc72db7f..53f5eb8e806 100755 --- a/gcc/configure +++ b/gcc/configure @@ -8458,12 +8458,12 @@ else int main() { return elf_getshstrndx (NULL, 0) == 0; -}, -$as_echo "#define HAVE_ELF_GETSHSTRNDX_GABI 1" >>confdefs.h - +} _ACEOF if ac_fn_c_try_run "$LINENO"; then : +$as_echo "#define HAVE_ELF_GETSHSTRNDX_GABI 1" >>confdefs.h + fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext diff --git a/gcc/configure.ac b/gcc/configure.ac index d256b62b104..2f571e6482d 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -1034,8 +1034,8 @@ AC_CHECK_FUNCS(elf_getshdrstrndx,, int main() { return elf_getshstrndx (NULL, 0) == 0; -}]]), AC_DEFINE(HAVE_ELF_GETSHSTRNDX_GABI, 1, - [Define if elf_getshstrndx has gABI conformant return values.])])])] +}]])], AC_DEFINE(HAVE_ELF_GETSHSTRNDX_GABI, 1, + [Define if elf_getshstrndx has gABI conformant return values.]))])] ) LIBS="$save_LIBS" CPPFLAGS="$save_CPPFLAGS" diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 6a11a946300..6dec7c38cad 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,41 @@ +2010-04-20 Jason Merrill + + PR c++/9335 + * init.c (constant_value_1): Treat error_mark_node as a constant + if DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P is set. + * cvt.c (ocp_convert): Handle getting error_mark_node from + integral_constant_value. + * decl.c (compute_array_index_type): Likewise. + +2010-04-20 Dodji Seketeli + + PR c++/43800 + PR c++/43704 + * typeck.c (incompatible_dependent_types_p): If one of the + compared types if not a typedef then honour their main variant + equivalence. + +2010-04-20 Jakub Jelinek + + * cp-tree.h (TYPE_REF_IS_RVALUE): Remove. + +2010-04-19 Dodji Seketeli + + PR c++/43704 + * typeck.c (structural_comptypes): Test dependent typedefs + incompatibility before testing for their main variant based + equivalence. + +2010-04-19 Jakub Jelinek + + * cp-tree.h (SCOPED_ENUM_P, UNSCOPED_ENUM_P, SET_SCOPED_ENUM_P): Use + ENUM_IS_SCOPED bit instead of TYPE_LANG_FLAG_5. + +2010-04-18 Eric Botcazou + + * decl.c (cxx_init_decl_processing): Remove second argument in call to + build_common_tree_nodes. + 2010-04-14 Jason Merrill PR c++/36625 diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 8f74a29e072..5afa0ea66cd 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -74,7 +74,6 @@ framework extensions, you must include this file before toplev.h, not after. BASELINK_QUALIFIED_P (in BASELINK) TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR) TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX) - TYPE_REF_IS_RVALUE (in REFERENCE_TYPE) ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute) CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR) LAMBDA_EXPR_CAPTURES_THIS_P (in LAMBDA_EXPR) @@ -121,7 +120,6 @@ framework extensions, you must include this file before toplev.h, not after. 3: TYPE_FOR_JAVA. 4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR 5: CLASS_TYPE_P (in RECORD_TYPE and UNION_TYPE) - SCOPED_ENUM_P (in ENUMERAL_TYPE) 6: TYPE_DEPENDENT_P_VALID Usage of DECL_LANG_FLAG_?: @@ -3036,17 +3034,17 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter) - The underlying type of the enum is well-defined. */ #define SCOPED_ENUM_P(TYPE) \ - (TREE_CODE (TYPE) == ENUMERAL_TYPE && TYPE_LANG_FLAG_5 (TYPE)) + (TREE_CODE (TYPE) == ENUMERAL_TYPE && ENUM_IS_SCOPED (TYPE)) /* Determine whether this is an unscoped enumeration type. */ #define UNSCOPED_ENUM_P(TYPE) \ - (TREE_CODE (TYPE) == ENUMERAL_TYPE && !TYPE_LANG_FLAG_5 (TYPE)) + (TREE_CODE (TYPE) == ENUMERAL_TYPE && !ENUM_IS_SCOPED (TYPE)) /* Set the flag indicating whether an ENUMERAL_TYPE is a C++0x scoped enumeration type (1) or a normal (unscoped) enumeration type (0). */ #define SET_SCOPED_ENUM_P(TYPE, VAL) \ - (TYPE_LANG_FLAG_5 (ENUMERAL_TYPE_CHECK (TYPE)) = (VAL)) + (ENUM_IS_SCOPED (TYPE) = (VAL)) /* Returns the underlying type of the given enumeration type. The underlying type is determined in different ways, depending on the @@ -3201,10 +3199,6 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter) #define TYPE_REF_OBJ_P(NODE) \ (TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE))) -/* True if reference type NODE is an rvalue reference */ -#define TYPE_REF_IS_RVALUE(NODE) \ - TREE_LANG_FLAG_0 (REFERENCE_TYPE_CHECK (NODE)) - /* Returns true if NODE is a pointer to an object, or a pointer to void. Keep these checks in ascending tree code order. */ #define TYPE_PTROBV_P(NODE) \ diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c index 6fcb1f0a19a..1f87c5f8c26 100644 --- a/gcc/cp/cvt.c +++ b/gcc/cp/cvt.c @@ -610,6 +610,8 @@ ocp_convert (tree type, tree expr, int convtype, int flags) } e = integral_constant_value (e); + if (error_operand_p (e)) + return error_mark_node; if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP)) /* We need a new temporary; don't take this shortcut. */; diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 26383c8f458..3a42ce9c900 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -3391,7 +3391,7 @@ cxx_init_decl_processing (void) tree void_ftype; tree void_ftype_ptr; - build_common_tree_nodes (flag_signed_char, false); + build_common_tree_nodes (flag_signed_char); /* Create all the identifiers we need. */ initialize_predefined_identifiers (); @@ -7352,6 +7352,8 @@ compute_array_index_type (tree name, tree size) /* It might be a const variable or enumeration constant. */ size = integral_constant_value (size); + if (error_operand_p (size)) + return error_mark_node; /* Normally, the array-bound will be a constant. */ if (TREE_CODE (size) == INTEGER_CST) diff --git a/gcc/cp/init.c b/gcc/cp/init.c index c1f1cbf4a38..e1dee1d10dc 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -1658,7 +1658,14 @@ constant_value_1 (tree decl, bool integral_p) init = DECL_INITIAL (decl); } if (init == error_mark_node) - return decl; + { + if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)) + /* Treat the error as a constant to avoid cascading errors on + excessively recursive template instantiation (c++/9335). */ + return init; + else + return decl; + } /* Initializers in templates are generally expanded during instantiation, so before that for const int i(2) INIT is a TREE_LIST with the actual initializer as diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 9947384976d..59c72149995 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -1155,6 +1155,7 @@ static bool incompatible_dependent_types_p (tree t1, tree t2) { tree tparms1 = NULL_TREE, tparms2 = NULL_TREE; + bool t1_typedef_variant_p, t2_typedef_variant_p; if (!uses_template_parms (t1) || !uses_template_parms (t2)) return false; @@ -1167,10 +1168,22 @@ incompatible_dependent_types_p (tree t1, tree t2) return true; } + t1_typedef_variant_p = typedef_variant_p (t1); + t2_typedef_variant_p = typedef_variant_p (t2); + /* Either T1 or T2 must be a typedef. */ - if (!typedef_variant_p (t1) && !typedef_variant_p (t2)) + if (!t1_typedef_variant_p && !t2_typedef_variant_p) return false; + if (!t1_typedef_variant_p || !t2_typedef_variant_p) + /* Either T1 or T2 is not a typedef so we cannot compare the + the template parms of the typedefs of T1 and T2. + At this point, if the main variant type of T1 and T2 are equal + it means the two types can't be incompatible, from the perspective + of this function. */ + if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) + return false; + /* So if we reach this point, it means either T1 or T2 is a typedef variant. Let's compare their template parameters. */ @@ -1236,6 +1249,12 @@ structural_comptypes (tree t1, tree t2, int strict) if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2)) return false; + /* If T1 and T2 are dependent typedefs then check upfront that + the template parameters of their typedef DECLs match before + going down checking their subtypes. */ + if (incompatible_dependent_types_p (t1, t2)) + return false; + /* Allow for two different type nodes which have essentially the same definition. Note that we already checked for equality of the type qualifiers (just above). */ @@ -1244,11 +1263,6 @@ structural_comptypes (tree t1, tree t2, int strict) && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) return true; - /* If T1 and T2 are dependent typedefs then check upfront that - the template parameters of their typedef DECLs match before - going down checking their subtypes. */ - if (incompatible_dependent_types_p (t1, t2)) - return false; /* Compare the types. Break out if they could be the same. */ switch (TREE_CODE (t1)) diff --git a/gcc/df-problems.c b/gcc/df-problems.c index e0ec16778f0..fb899096e49 100644 --- a/gcc/df-problems.c +++ b/gcc/df-problems.c @@ -3745,9 +3745,22 @@ df_simulate_find_defs (rtx insn, bitmap defs) for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++) { df_ref def = *def_rec; - /* If the def is to only part of the reg, it does - not kill the other defs that reach here. */ - if (!(DF_REF_FLAGS (def) & (DF_REF_PARTIAL | DF_REF_CONDITIONAL))) + bitmap_set_bit (defs, DF_REF_REGNO (def)); + } +} + +/* Find the set of real DEFs, which are not clobbers, for INSN. */ + +void +df_simulate_find_noclobber_defs (rtx insn, bitmap defs) +{ + df_ref *def_rec; + unsigned int uid = INSN_UID (insn); + + for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++) + { + df_ref def = *def_rec; + if (!(DF_REF_FLAGS (def) & (DF_REF_MUST_CLOBBER | DF_REF_MAY_CLOBBER))) bitmap_set_bit (defs, DF_REF_REGNO (def)); } } @@ -3939,7 +3952,7 @@ df_simulate_one_insn_forwards (basic_block bb, rtx insn, bitmap live) while here the scan is performed forwards! So, first assume that the def is live, and if this is not true REG_UNUSED notes will rectify the situation. */ - df_simulate_find_defs (insn, live); + df_simulate_find_noclobber_defs (insn, live); /* Clear all of the registers that go dead. */ for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) diff --git a/gcc/df.h b/gcc/df.h index 194cbcf2639..c73f00fe6ce 100644 --- a/gcc/df.h +++ b/gcc/df.h @@ -978,6 +978,7 @@ extern void df_note_add_problem (void); extern void df_md_add_problem (void); extern void df_md_simulate_artificial_defs_at_top (basic_block, bitmap); extern void df_md_simulate_one_insn (basic_block, rtx, bitmap); +extern void df_simulate_find_noclobber_defs (rtx, bitmap); extern void df_simulate_find_defs (rtx, bitmap); extern void df_simulate_defs (rtx, bitmap); extern void df_simulate_uses (rtx, bitmap); diff --git a/gcc/dojump.c b/gcc/dojump.c index c2ee427d7ac..d4ce6cfc458 100644 --- a/gcc/dojump.c +++ b/gcc/dojump.c @@ -163,7 +163,8 @@ prefer_and_bit_test (enum machine_mode mode, int bitnum) /* Fill in the integers. */ XEXP (and_test, 1) - = immed_double_const ((unsigned HOST_WIDE_INT) 1 << bitnum, 0, mode); + = immed_double_int_const (double_int_setbit (double_int_zero, bitnum), + mode); XEXP (XEXP (shift_test, 0), 1) = GEN_INT (bitnum); return (rtx_cost (and_test, IF_THEN_ELSE, optimize_insn_for_speed_p ()) diff --git a/gcc/double-int.c b/gcc/double-int.c index 2af97ba0c62..8e4a3f5e596 100644 --- a/gcc/double-int.c +++ b/gcc/double-int.c @@ -1013,6 +1013,18 @@ double_int_umod (double_int a, double_int b, unsigned code) return double_int_mod (a, b, true, code); } +/* Set BITPOS bit in A. */ +double_int +double_int_setbit (double_int a, unsigned bitpos) +{ + if (bitpos < HOST_BITS_PER_WIDE_INT) + a.low |= (unsigned HOST_WIDE_INT) 1 << bitpos; + else + a.high |= (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT); + + return a; +} + /* Shift A left by COUNT places keeping only PREC bits of result. Shift right if COUNT is negative. ARITH true specifies arithmetic shifting; otherwise use logical shift. */ diff --git a/gcc/double-int.h b/gcc/double-int.h index 682034859b9..47991ca41b8 100644 --- a/gcc/double-int.h +++ b/gcc/double-int.h @@ -130,6 +130,7 @@ double_int double_int_umod (double_int, double_int, unsigned); double_int double_int_divmod (double_int, double_int, bool, unsigned, double_int *); double_int double_int_sdivmod (double_int, double_int, unsigned, double_int *); double_int double_int_udivmod (double_int, double_int, unsigned, double_int *); +double_int double_int_setbit (double_int, unsigned); /* Logical operations. */ static inline double_int diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index 5a9a3b89dc0..e7e2e8f9a72 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -3771,6 +3771,11 @@ output_call_frame_info (int for_eh) } dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation"); + if (dw_cie_version >= 4) + { + dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size"); + dw2_asm_output_data (1, 0, "CIE Segment Size"); + } dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor"); dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, "CIE Data Alignment Factor"); @@ -5710,8 +5715,7 @@ static GTY(()) comdat_type_node *comdat_type_list; static GTY(()) limbo_die_node *limbo_die_list; /* A list of DIEs for which we may have to generate - DW_AT_MIPS_linkage_name once their DECL_ASSEMBLER_NAMEs are - set. */ + DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */ static GTY(()) limbo_die_node *deferred_asm_name; /* Filenames referenced by this compilation unit. */ @@ -5744,8 +5748,12 @@ struct GTY ((chain_next ("%h.next"))) var_loc_node { struct GTY (()) var_loc_list_def { struct var_loc_node * GTY (()) first; - /* Do not mark the last element of the chained list because - it is marked through the chain. */ + /* Pointer to the last but one or last element of the + chained list. If the list is empty, both first and + last are NULL, if the list contains just one node + or the last node certainly is not redundant, it points + to the last node, otherwise points to the last but one. + Do not mark it for GC because it is marked through the chain. */ struct var_loc_node * GTY ((skip ("%h"))) last; /* DECL_UID of the variable decl. */ @@ -5987,7 +5995,7 @@ static hashval_t decl_loc_table_hash (const void *); static int decl_loc_table_eq (const void *, const void *); static var_loc_list *lookup_decl_loc (const_tree); static void equate_decl_number_to_die (tree, dw_die_ref); -static struct var_loc_node *add_var_loc_to_decl (tree, rtx); +static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *); static void print_spaces (FILE *); static void print_die (dw_die_ref, FILE *); static void print_dwarf_line_table (FILE *); @@ -6273,6 +6281,12 @@ static void gen_remaining_tmpl_value_param_die_attribute (void); #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo" #endif +/* Mangled name attribute to use. This used to be a vendor extension + until DWARF 4 standardized it. */ +#define AT_linkage_name \ + (dwarf_version >= 4 ? DW_AT_linkage_name : DW_AT_MIPS_linkage_name) + + /* Definitions of defaults for formats and names of various special (artificial) labels which may be generated within this file (when the -g options is used and DWARF2_DEBUGGING_INFO is in effect. @@ -7745,7 +7759,7 @@ equate_decl_number_to_die (tree decl, dw_die_ref decl_die) /* Add a variable location node to the linked list for DECL. */ static struct var_loc_node * -add_var_loc_to_decl (tree decl, rtx loc_note) +add_var_loc_to_decl (tree decl, rtx loc_note, const char *label) { unsigned int decl_id = DECL_UID (decl); var_loc_list *temp; @@ -7764,23 +7778,62 @@ add_var_loc_to_decl (tree decl, rtx loc_note) if (temp->last) { + struct var_loc_node *last = temp->last, *unused = NULL; + if (last->next) + { + last = last->next; + gcc_assert (last->next == NULL); + } + /* TEMP->LAST here is either pointer to the last but one or + last element in the chained list, LAST is pointer to the + last element. */ + /* If the last note doesn't cover any instructions, remove it. */ + if (label && strcmp (last->label, label) == 0) + { + if (temp->last != last) + { + temp->last->next = NULL; + unused = last; + last = temp->last; + gcc_assert (strcmp (last->label, label) != 0); + } + else + { + gcc_assert (temp->first == temp->last); + memset (temp->last, '\0', sizeof (*temp->last)); + return temp->last; + } + } /* If the current location is the same as the end of the list, and either both or neither of the locations is uninitialized, we have nothing to do. */ - if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note), + if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last->var_loc_note), NOTE_VAR_LOCATION_LOC (loc_note))) - || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note) + || ((NOTE_VAR_LOCATION_STATUS (last->var_loc_note) != NOTE_VAR_LOCATION_STATUS (loc_note)) - && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note) + && ((NOTE_VAR_LOCATION_STATUS (last->var_loc_note) == VAR_INIT_STATUS_UNINITIALIZED) || (NOTE_VAR_LOCATION_STATUS (loc_note) == VAR_INIT_STATUS_UNINITIALIZED)))) { - /* Add LOC to the end of list and update LAST. */ - loc = GGC_CNEW (struct var_loc_node); - temp->last->next = loc; - temp->last = loc; + /* Add LOC to the end of list and update LAST. If the last + element of the list has been removed above, reuse its + memory for the new node, otherwise allocate a new one. */ + if (unused) + { + loc = unused; + memset (loc, '\0', sizeof (*loc)); + } + else + loc = GGC_CNEW (struct var_loc_node); + last->next = loc; + /* Ensure TEMP->LAST will point either to the new last but one + element of the chain, or to the last element in it. */ + if (last != temp->last) + temp->last = last; } + else if (unused) + ggc_free (unused); } else { @@ -8245,6 +8298,7 @@ attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at, if ((at->dw_attr == DW_AT_type && (tag == DW_TAG_pointer_type || tag == DW_TAG_reference_type + || tag == DW_TAG_rvalue_reference_type || tag == DW_TAG_ptr_to_member_type)) || (at->dw_attr == DW_AT_friend && tag == DW_TAG_friend)) @@ -8959,6 +9013,7 @@ is_type_die (dw_die_ref die) case DW_TAG_enumeration_type: case DW_TAG_pointer_type: case DW_TAG_reference_type: + case DW_TAG_rvalue_reference_type: case DW_TAG_string_type: case DW_TAG_structure_type: case DW_TAG_subroutine_type: @@ -8996,6 +9051,7 @@ is_comdat_die (dw_die_ref c) if (c->die_tag == DW_TAG_pointer_type || c->die_tag == DW_TAG_reference_type + || c->die_tag == DW_TAG_rvalue_reference_type || c->die_tag == DW_TAG_const_type || c->die_tag == DW_TAG_volatile_type) { @@ -9244,6 +9300,7 @@ should_move_die_to_comdat (dw_die_ref die) case DW_TAG_interface_type: case DW_TAG_pointer_type: case DW_TAG_reference_type: + case DW_TAG_rvalue_reference_type: case DW_TAG_string_type: case DW_TAG_subroutine_type: case DW_TAG_ptr_to_member_type: @@ -9327,6 +9384,7 @@ clone_as_declaration (dw_die_ref die) case DW_AT_name: case DW_AT_type: case DW_AT_virtuality: + case DW_AT_linkage_name: case DW_AT_MIPS_linkage_name: add_dwarf_attr (clone, a); break; @@ -12192,7 +12250,11 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type, } else if (code == REFERENCE_TYPE) { - mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type); + if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4) + mod_type_die = new_die (DW_TAG_rvalue_reference_type, comp_unit_die, + type); + else + mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type); add_AT_unsigned (mod_type_die, DW_AT_byte_size, simple_type_size_in_bits (type) / BITS_PER_UNIT); item_type = TREE_TYPE (type); @@ -15906,7 +15968,7 @@ add_location_or_const_value_attribute (dw_die_ref die, tree decl, loc_list = lookup_decl_loc (decl); if (loc_list && loc_list->first - && loc_list->first == loc_list->last + && loc_list->first->next == NULL && NOTE_VAR_LOCATION (loc_list->first->var_loc_note) && NOTE_VAR_LOCATION_LOC (loc_list->first->var_loc_note)) { @@ -16335,6 +16397,7 @@ lower_bound_default (void) return 1; case DW_LANG_UPC: case DW_LANG_D: + case DW_LANG_Python: return dwarf_version >= 4 ? 0 : -1; case DW_LANG_Ada95: case DW_LANG_Ada83: @@ -16745,8 +16808,7 @@ add_name_and_src_coords_attributes (dw_die_ref die, tree decl) if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) && TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl) - && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)) - && !is_fortran ()) + && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))) { /* Defer until we have an assembler name set. */ if (!DECL_ASSEMBLER_NAME_SET_P (decl)) @@ -16760,7 +16822,7 @@ add_name_and_src_coords_attributes (dw_die_ref die, tree decl) deferred_asm_name = asm_name; } else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)) - add_AT_string (die, DW_AT_MIPS_linkage_name, + add_AT_string (die, AT_linkage_name, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); } } @@ -17385,6 +17447,9 @@ gen_enumeration_type_die (tree type, dw_die_ref context_die) scope_die_for (type, context_die), type); equate_type_number_to_die (type, type_die); add_name_attribute (type_die, type_tag (type)); + if ((dwarf_version >= 4 || !dwarf_strict) + && ENUM_IS_SCOPED (type)) + add_AT_flag (type_die, DW_AT_enum_class, 1); } else if (! TYPE_SIZE (type)) return type_die; @@ -18630,8 +18695,12 @@ gen_pointer_type_die (tree type, dw_die_ref context_die) static void gen_reference_type_die (tree type, dw_die_ref context_die) { - dw_die_ref ref_die - = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type); + dw_die_ref ref_die, scope_die = scope_die_for (type, context_die); + + if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4) + ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type); + else + ref_die = new_die (DW_TAG_reference_type, scope_die, type); equate_type_number_to_die (type, ref_die); add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die); @@ -20357,22 +20426,33 @@ dwarf2out_var_location (rtx loc_note) if (next_real == NULL_RTX) return; + /* If there were any real insns between note we processed last time + and this note (or if it is the first note), clear + last_{,postcall_}label so that they are not reused this time. */ + if (last_var_location_insn == NULL_RTX + || last_var_location_insn != next_real + || last_in_cold_section_p != in_cold_section_p) + { + last_label = NULL; + last_postcall_label = NULL; + } + decl = NOTE_VAR_LOCATION_DECL (loc_note); - newloc = add_var_loc_to_decl (decl, loc_note); + newloc = add_var_loc_to_decl (decl, loc_note, + NOTE_DURING_CALL_P (loc_note) + ? last_postcall_label : last_label); if (newloc == NULL) return; /* If there were no real insns between note we processed last time - and this note, use the label we emitted last time. */ - if (last_var_location_insn == NULL_RTX - || last_var_location_insn != next_real - || last_in_cold_section_p != in_cold_section_p) + and this note, use the label we emitted last time. Otherwise + create a new label and emit it. */ + if (last_label == NULL) { ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num); ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num); loclabel_num++; last_label = ggc_strdup (loclabel); - last_postcall_label = NULL; } newloc->var_loc_note = loc_note; newloc->next = NULL; @@ -20903,6 +20983,7 @@ prune_unused_types_walk (dw_die_ref die) case DW_TAG_packed_type: case DW_TAG_pointer_type: case DW_TAG_reference_type: + case DW_TAG_rvalue_reference_type: case DW_TAG_volatile_type: case DW_TAG_typedef: case DW_TAG_array_type: @@ -21122,7 +21203,7 @@ htab_ct_eq (const void *of1, const void *of2) DWARF_TYPE_SIGNATURE_SIZE)); } -/* Move a DW_AT_MIPS_linkage_name attribute just added to dw_die_ref +/* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref to the location it would have been added, should we know its DECL_ASSEMBLER_NAME when we added other attributes. This will probably improve compactness of debug info, removing equivalent @@ -21135,7 +21216,7 @@ move_linkage_attr (dw_die_ref die) unsigned ix = VEC_length (dw_attr_node, die->die_attr); dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1); - gcc_assert (linkage.dw_attr == DW_AT_MIPS_linkage_name); + gcc_assert (linkage.dw_attr == AT_linkage_name); while (--ix > 0) { @@ -21369,7 +21450,7 @@ dwarf2out_finish (const char *filename) tree decl = node->created_for; if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)) { - add_AT_string (node->die, DW_AT_MIPS_linkage_name, + add_AT_string (node->die, AT_linkage_name, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); move_linkage_attr (node->die); } diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c index ab46195fcb9..d4ba5d706ed 100644 --- a/gcc/emit-rtl.c +++ b/gcc/emit-rtl.c @@ -1,6 +1,7 @@ /* Emit RTL for the GCC expander. Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, + 2010 Free Software Foundation, Inc. This file is part of GCC. @@ -517,6 +518,15 @@ const_fixed_from_fixed_value (FIXED_VALUE_TYPE value, enum machine_mode mode) return lookup_const_fixed (fixed); } +/* Return a CONST_DOUBLE or CONST_INT for a value specified as + a double_int. */ + +rtx +immed_double_int_const (double_int i, enum machine_mode mode) +{ + return immed_double_const (i.low, i.high, mode); +} + /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints: I0 is the low-order word and I1 is the high-order word. Do not use this routine for non-integer modes; convert to diff --git a/gcc/expmed.c b/gcc/expmed.c index 44de4a6512e..07b1dc6d70d 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -1847,7 +1847,7 @@ mask_rtx (enum machine_mode mode, int bitpos, int bitsize, int complement) if (complement) mask = double_int_not (mask); - return immed_double_const (mask.low, mask.high, mode); + return immed_double_int_const (mask, mode); } /* Return a constant integer (CONST_INT or CONST_DOUBLE) rtx with the value @@ -1861,7 +1861,7 @@ lshift_value (enum machine_mode mode, rtx value, int bitpos, int bitsize) val = double_int_zext (uhwi_to_double_int (INTVAL (value)), bitsize); val = double_int_lshift (val, bitpos, HOST_BITS_PER_DOUBLE_INT, false); - return immed_double_const (val.low, val.high, mode); + return immed_double_int_const (val, mode); } /* Extract a bit field that is split across two words @@ -3217,6 +3217,55 @@ expand_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target, gcc_assert (op0); return op0; } + +/* Perform a widening multiplication and return an rtx for the result. + MODE is mode of value; OP0 and OP1 are what to multiply (rtx's); + TARGET is a suggestion for where to store the result (an rtx). + THIS_OPTAB is the optab we should use, it must be either umul_widen_optab + or smul_widen_optab. + + We check specially for a constant integer as OP1, comparing the + cost of a widening multiply against the cost of a sequence of shifts + and adds. */ + +rtx +expand_widening_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target, + int unsignedp, optab this_optab) +{ + bool speed = optimize_insn_for_speed_p (); + + if (CONST_INT_P (op1) + && (INTVAL (op1) >= 0 + || GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)) + { + HOST_WIDE_INT coeff = INTVAL (op1); + int max_cost; + enum mult_variant variant; + struct algorithm algorithm; + + /* Special case powers of two. */ + if (EXACT_POWER_OF_2_OR_ZERO_P (coeff)) + { + op0 = convert_to_mode (mode, op0, this_optab == umul_widen_optab); + return expand_shift (LSHIFT_EXPR, mode, op0, + build_int_cst (NULL_TREE, floor_log2 (coeff)), + target, unsignedp); + } + + /* Exclude cost of op0 from max_cost to match the cost + calculation of the synth_mult. */ + max_cost = mul_widen_cost[speed][mode]; + if (choose_mult_variant (mode, coeff, &algorithm, &variant, + max_cost)) + { + op0 = convert_to_mode (mode, op0, this_optab == umul_widen_optab); + return expand_mult_const (mode, op0, coeff, target, + &algorithm, variant); + } + } + return expand_binop (mode, this_optab, op0, op1, target, + unsignedp, OPTAB_LIB_WIDEN); +} /* Return the smallest n such that 2**n >= X. */ diff --git a/gcc/expr.c b/gcc/expr.c index 930ee98a438..5448bbe2b8f 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -774,18 +774,13 @@ convert_modes (enum machine_mode mode, enum machine_mode oldmode, rtx x, int uns && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT && CONST_INT_P (x) && INTVAL (x) < 0) { - HOST_WIDE_INT val = INTVAL (x); + double_int val = uhwi_to_double_int (INTVAL (x)); - if (oldmode != VOIDmode - && HOST_BITS_PER_WIDE_INT > GET_MODE_BITSIZE (oldmode)) - { - int width = GET_MODE_BITSIZE (oldmode); - - /* We need to zero extend VAL. */ - val &= ((HOST_WIDE_INT) 1 << width) - 1; - } + /* We need to zero extend VAL. */ + if (oldmode != VOIDmode) + val = double_int_zext (val, GET_MODE_BITSIZE (oldmode)); - return immed_double_const (val, (HOST_WIDE_INT) 0, mode); + return immed_double_int_const (val, mode); } /* We can do this with a gen_lowpart if both desired and current modes @@ -7217,7 +7212,6 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode, optab this_optab; rtx subtarget, original_target; int ignore; - tree subexp0, subexp1; bool reduce_bit_field; gimple subexp0_def, subexp1_def; tree top0, top1; @@ -7672,13 +7666,7 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode, goto binop2; - case MULT_EXPR: - /* If this is a fixed-point operation, then we cannot use the code - below because "expand_mult" doesn't support sat/no-sat fixed-point - multiplications. */ - if (ALL_FIXED_POINT_MODE_P (mode)) - goto binop; - + case WIDEN_MULT_EXPR: /* If first operand is constant, swap them. Thus the following special case checks need only check the second operand. */ @@ -7689,96 +7677,35 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode, treeop1 = t1; } - /* Attempt to return something suitable for generating an - indexed address, for machines that support that. */ - - if (modifier == EXPAND_SUM && mode == ptr_mode - && host_integerp (treeop1, 0)) - { - tree exp1 = treeop1; - - op0 = expand_expr (treeop0, subtarget, VOIDmode, - EXPAND_SUM); - - if (!REG_P (op0)) - op0 = force_operand (op0, NULL_RTX); - if (!REG_P (op0)) - op0 = copy_to_mode_reg (mode, op0); - - return REDUCE_BIT_FIELD (gen_rtx_MULT (mode, op0, - gen_int_mode (tree_low_cst (exp1, 0), - TYPE_MODE (TREE_TYPE (exp1))))); - } - - if (modifier == EXPAND_STACK_PARM) - target = 0; - - /* Check for multiplying things that have been extended - from a narrower type. If this machine supports multiplying - in that narrower type with a result in the desired type, - do it that way, and avoid the explicit type-conversion. */ - - subexp0 = treeop0; - subexp1 = treeop1; - subexp0_def = get_def_for_expr (subexp0, NOP_EXPR); - subexp1_def = get_def_for_expr (subexp1, NOP_EXPR); - top0 = top1 = NULL_TREE; - /* First, check if we have a multiplication of one signed and one unsigned operand. */ - if (subexp0_def - && (top0 = gimple_assign_rhs1 (subexp0_def)) - && subexp1_def - && (top1 = gimple_assign_rhs1 (subexp1_def)) - && TREE_CODE (type) == INTEGER_TYPE - && (TYPE_PRECISION (TREE_TYPE (top0)) - < TYPE_PRECISION (TREE_TYPE (subexp0))) - && (TYPE_PRECISION (TREE_TYPE (top0)) - == TYPE_PRECISION (TREE_TYPE (top1))) - && (TYPE_UNSIGNED (TREE_TYPE (top0)) - != TYPE_UNSIGNED (TREE_TYPE (top1)))) + if (TREE_CODE (treeop1) != INTEGER_CST + && (TYPE_UNSIGNED (TREE_TYPE (treeop0)) + != TYPE_UNSIGNED (TREE_TYPE (treeop1)))) { - enum machine_mode innermode - = TYPE_MODE (TREE_TYPE (top0)); + enum machine_mode innermode = TYPE_MODE (TREE_TYPE (treeop0)); this_optab = usmul_widen_optab; - if (mode == GET_MODE_WIDER_MODE (innermode)) + if (mode == GET_MODE_2XWIDER_MODE (innermode)) { if (optab_handler (this_optab, mode)->insn_code != CODE_FOR_nothing) { - if (TYPE_UNSIGNED (TREE_TYPE (top0))) - expand_operands (top0, top1, NULL_RTX, &op0, &op1, + if (TYPE_UNSIGNED (TREE_TYPE (treeop0))) + expand_operands (treeop0, treeop1, subtarget, &op0, &op1, EXPAND_NORMAL); else - expand_operands (top0, top1, NULL_RTX, &op1, &op0, + expand_operands (treeop0, treeop1, subtarget, &op1, &op0, EXPAND_NORMAL); - goto binop3; } } } - /* Check for a multiplication with matching signedness. If - valid, TOP0 and TOP1 were set in the previous if - condition. */ - else if (top0 - && TREE_CODE (type) == INTEGER_TYPE - && (TYPE_PRECISION (TREE_TYPE (top0)) - < TYPE_PRECISION (TREE_TYPE (subexp0))) - && ((TREE_CODE (subexp1) == INTEGER_CST - && int_fits_type_p (subexp1, TREE_TYPE (top0)) - /* Don't use a widening multiply if a shift will do. */ - && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (subexp1))) - > HOST_BITS_PER_WIDE_INT) - || exact_log2 (TREE_INT_CST_LOW (subexp1)) < 0)) - || - (top1 - && (TYPE_PRECISION (TREE_TYPE (top1)) - == TYPE_PRECISION (TREE_TYPE (top0)) - /* If both operands are extended, they must either both - be zero-extended or both be sign-extended. */ - && (TYPE_UNSIGNED (TREE_TYPE (top1)) - == TYPE_UNSIGNED (TREE_TYPE (top0))))))) + /* Check for a multiplication with matching signedness. */ + else if ((TREE_CODE (treeop1) == INTEGER_CST + && int_fits_type_p (treeop1, TREE_TYPE (treeop0))) + || (TYPE_UNSIGNED (TREE_TYPE (treeop1)) + == TYPE_UNSIGNED (TREE_TYPE (treeop0)))) { - tree op0type = TREE_TYPE (top0); + tree op0type = TREE_TYPE (treeop0); enum machine_mode innermode = TYPE_MODE (op0type); bool zextend_p = TYPE_UNSIGNED (op0type); optab other_optab = zextend_p ? smul_widen_optab : umul_widen_optab; @@ -7788,24 +7715,22 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode, { if (optab_handler (this_optab, mode)->insn_code != CODE_FOR_nothing) { - if (TREE_CODE (subexp1) == INTEGER_CST) - expand_operands (top0, subexp1, NULL_RTX, &op0, &op1, - EXPAND_NORMAL); - else - expand_operands (top0, top1, NULL_RTX, &op0, &op1, - EXPAND_NORMAL); - goto binop3; + expand_operands (treeop0, treeop1, NULL_RTX, &op0, &op1, + EXPAND_NORMAL); + temp = expand_widening_mult (mode, op0, op1, target, + unsignedp, this_optab); + return REDUCE_BIT_FIELD (temp); } - else if (optab_handler (other_optab, mode)->insn_code != CODE_FOR_nothing - && innermode == word_mode) + if (optab_handler (other_optab, mode)->insn_code != CODE_FOR_nothing + && innermode == word_mode) { rtx htem, hipart; - op0 = expand_normal (top0); - if (TREE_CODE (subexp1) == INTEGER_CST) + op0 = expand_normal (treeop0); + if (TREE_CODE (treeop1) == INTEGER_CST) op1 = convert_modes (innermode, mode, - expand_normal (subexp1), unsignedp); + expand_normal (treeop1), unsignedp); else - op1 = expand_normal (top1); + op1 = expand_normal (treeop1); temp = expand_binop (mode, other_optab, op0, op1, target, unsignedp, OPTAB_LIB_WIDEN); hipart = gen_highpart (innermode, temp); @@ -7818,7 +7743,53 @@ expand_expr_real_2 (sepops ops, rtx target, enum machine_mode tmode, } } } - expand_operands (subexp0, subexp1, subtarget, &op0, &op1, EXPAND_NORMAL); + treeop0 = fold_build1 (CONVERT_EXPR, type, treeop0); + treeop1 = fold_build1 (CONVERT_EXPR, type, treeop1); + expand_operands (treeop0, treeop1, subtarget, &op0, &op1, EXPAND_NORMAL); + return REDUCE_BIT_FIELD (expand_mult (mode, op0, op1, target, unsignedp)); + + case MULT_EXPR: + /* If this is a fixed-point operation, then we cannot use the code + below because "expand_mult" doesn't support sat/no-sat fixed-point + multiplications. */ + if (ALL_FIXED_POINT_MODE_P (mode)) + goto binop; + + /* If first operand is constant, swap them. + Thus the following special case checks need only + check the second operand. */ + if (TREE_CODE (treeop0) == INTEGER_CST) + { + tree t1 = treeop0; + treeop0 = treeop1; + treeop1 = t1; + } + + /* Attempt to return something suitable for generating an + indexed address, for machines that support that. */ + + if (modifier == EXPAND_SUM && mode == ptr_mode + && host_integerp (treeop1, 0)) + { + tree exp1 = treeop1; + + op0 = expand_expr (treeop0, subtarget, VOIDmode, + EXPAND_SUM); + + if (!REG_P (op0)) + op0 = force_operand (op0, NULL_RTX); + if (!REG_P (op0)) + op0 = copy_to_mode_reg (mode, op0); + + return REDUCE_BIT_FIELD (gen_rtx_MULT (mode, op0, + gen_int_mode (tree_low_cst (exp1, 0), + TYPE_MODE (TREE_TYPE (exp1))))); + } + + if (modifier == EXPAND_STACK_PARM) + target = 0; + + expand_operands (treeop0, treeop1, subtarget, &op0, &op1, EXPAND_NORMAL); return REDUCE_BIT_FIELD (expand_mult (mode, op0, op1, target, unsignedp)); case TRUNC_DIV_EXPR: @@ -9686,15 +9657,8 @@ reduce_to_bit_field_precision (rtx exp, rtx target, tree type) } else if (TYPE_UNSIGNED (type)) { - rtx mask; - if (prec < HOST_BITS_PER_WIDE_INT) - mask = immed_double_const (((unsigned HOST_WIDE_INT) 1 << prec) - 1, 0, - GET_MODE (exp)); - else - mask = immed_double_const ((unsigned HOST_WIDE_INT) -1, - ((unsigned HOST_WIDE_INT) 1 - << (prec - HOST_BITS_PER_WIDE_INT)) - 1, - GET_MODE (exp)); + rtx mask = immed_double_int_const (double_int_mask (prec), + GET_MODE (exp)); return expand_and (GET_MODE (exp), exp, mask, target); } else @@ -10280,9 +10244,8 @@ const_vector_from_tree (tree exp) RTVEC_ELT (v, i) = CONST_FIXED_FROM_FIXED_VALUE (TREE_FIXED_CST (elt), inner); else - RTVEC_ELT (v, i) = immed_double_const (TREE_INT_CST_LOW (elt), - TREE_INT_CST_HIGH (elt), - inner); + RTVEC_ELT (v, i) = immed_double_int_const (tree_to_double_int (elt), + inner); } /* Initialize remaining elements to 0. */ diff --git a/gcc/fold-const.c b/gcc/fold-const.c index c1af8248a39..cdae661733c 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -8643,9 +8643,33 @@ fold_comparison (location_t loc, enum tree_code code, tree type, offset1 = TREE_OPERAND (arg1, 1); } + /* A local variable can never be pointed to by + the default SSA name of an incoming parameter. */ + if ((TREE_CODE (arg0) == ADDR_EXPR + && indirect_base0 + && TREE_CODE (base0) == VAR_DECL + && auto_var_in_fn_p (base0, current_function_decl) + && !indirect_base1 + && TREE_CODE (base1) == SSA_NAME + && TREE_CODE (SSA_NAME_VAR (base1)) == PARM_DECL + && SSA_NAME_IS_DEFAULT_DEF (base1)) + || (TREE_CODE (arg1) == ADDR_EXPR + && indirect_base1 + && TREE_CODE (base1) == VAR_DECL + && auto_var_in_fn_p (base1, current_function_decl) + && !indirect_base0 + && TREE_CODE (base0) == SSA_NAME + && TREE_CODE (SSA_NAME_VAR (base0)) == PARM_DECL + && SSA_NAME_IS_DEFAULT_DEF (base0))) + { + if (code == NE_EXPR) + return constant_boolean_node (1, type); + else if (code == EQ_EXPR) + return constant_boolean_node (0, type); + } /* If we have equivalent bases we might be able to simplify. */ - if (indirect_base0 == indirect_base1 - && operand_equal_p (base0, base1, 0)) + else if (indirect_base0 == indirect_base1 + && operand_equal_p (base0, base1, 0)) { /* We can fold this expression to a constant if the non-constant offset parts are equal. */ @@ -8695,24 +8719,19 @@ fold_comparison (location_t loc, enum tree_code code, tree type, && ((code == EQ_EXPR || code == NE_EXPR) || POINTER_TYPE_OVERFLOW_UNDEFINED)) { - tree signed_size_type_node; - signed_size_type_node = signed_type_for (size_type_node); - /* By converting to signed size type we cover middle-end pointer arithmetic which operates on unsigned pointer types of size type size and ARRAY_REF offsets which are properly sign or zero extended from their type in case it is narrower than size type. */ if (offset0 == NULL_TREE) - offset0 = build_int_cst (signed_size_type_node, 0); + offset0 = build_int_cst (ssizetype, 0); else - offset0 = fold_convert_loc (loc, signed_size_type_node, - offset0); + offset0 = fold_convert_loc (loc, ssizetype, offset0); if (offset1 == NULL_TREE) - offset1 = build_int_cst (signed_size_type_node, 0); + offset1 = build_int_cst (ssizetype, 0); else - offset1 = fold_convert_loc (loc, signed_size_type_node, - offset1); + offset1 = fold_convert_loc (loc, ssizetype, offset1); if (code != EQ_EXPR && code != NE_EXPR diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index b53aff9b83b..1c77717b4e8 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,61 @@ +2010-04-22 Richard Guenther + + PR fortran/43829 + * resolve.c (gfc_resolve_index): Wrap around ... + (gfc_resolve_index_1): ... this. Add parameter to allow + any integer kind index type. + (resolve_array_ref): Allow any integer kind for the start + index of an array ref. + +2010-04-21 Jakub Jelinek + + PR fortran/43836 + * f95-lang.c (gfc_define_builtin): Set TREE_NOTHROW on + the decl. + +2010-04-20 Harald Anlauf + + * intrinsic.c (sort_actual): Remove 'is' in error message. + +2010-04-20 Paul Thomas + + PR fortran/43227 + * resolve.c (resolve_fl_derived): If a component character + length has not been resolved, do so now. + (resolve_symbol): The same as above for a symbol character + length. + * trans-decl.c (gfc_create_module_variable): A 'length' decl is + not needed for a character valued, procedure pointer. + + PR fortran/43266 + * resolve.c (ensure_not_abstract_walker): If 'overriding' is + not found, return FAILURE rather than ICEing. + +2010-04-19 Jakub Jelinek + + PR fortran/43339 + * openmp.c (gfc_resolve_do_iterator): Only make iteration vars for + sequential loops private in the innermost containing task region. + +2010-04-18 Eric Botcazou + + * f95-lang.c (gfc_init_decl_processing): Remove second argument in call + to build_common_tree_nodes. + +2010-04-17 Steven G. Kargl + + PR fortran/31538 + * fortran/trans-array.c (gfc_conv_ss_startstride): Remove the use of + gfc_msg_bounds by using 'Array bound mismatch' directly. + (gfc_trans_dummy_array_bias): Remove the use of gfc_msg_bounds. Reword + error message to include the mismatch in the extent of array bound. + * fortran/trans.c: Remove gfc_msg_bounds. It is only used in one place. + * fortran/trans.h: Remove extern definition of gfc_msg_bounds. + +2010-04-17 Jerry DeLisle + + * gfortran.texi: Update information on temporary file locations. + 2010-04-16 Jakub Jelinek * trans-decl.c (gfc_build_qualified_array): Ensure diff --git a/gcc/fortran/f95-lang.c b/gcc/fortran/f95-lang.c index 5d2846c8890..8efa6de679b 100644 --- a/gcc/fortran/f95-lang.c +++ b/gcc/fortran/f95-lang.c @@ -1,5 +1,5 @@ /* gfortran backend interface - Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010 Free Software Foundation, Inc. Contributed by Paul Brook. @@ -542,7 +542,7 @@ gfc_init_decl_processing (void) /* Build common tree nodes. char_type_node is unsigned because we only use it for actual characters, not for INTEGER(1). Also, we want double_type_node to actually have double precision. */ - build_common_tree_nodes (false, false); + build_common_tree_nodes (false); /* x86_64 mingw32 has a sizetype of "unsigned long long", most other hosts have a sizetype of "unsigned long". Therefore choose the correct size in mostly target independent way. */ @@ -608,6 +608,7 @@ gfc_define_builtin (const char *name, library_name, NULL_TREE); if (const_p) TREE_READONLY (decl) = 1; + TREE_NOTHROW (decl) = 1; built_in_decls[code] = decl; implicit_built_in_decls[code] = decl; diff --git a/gcc/fortran/gfortran.texi b/gcc/fortran/gfortran.texi index 6ab413cbc3c..8a89699fc49 100644 --- a/gcc/fortran/gfortran.texi +++ b/gcc/fortran/gfortran.texi @@ -635,8 +635,8 @@ error is used. If the first letter is @samp{n}, @samp{N} or This environment variable controls where scratch files are created. If this environment variable is missing, -GNU Fortran searches for the environment variable @env{TMP}. If -this is also missing, the default is @file{/tmp}. +GNU Fortran searches for the environment variable @env{TMP}, then @env{TEMP}. +If these are missing, the default is @file{/tmp}. @node GFORTRAN_UNBUFFERED_ALL @section @env{GFORTRAN_UNBUFFERED_ALL}---Don't buffer I/O on all units diff --git a/gcc/fortran/intrinsic.c b/gcc/fortran/intrinsic.c index 470839af104..494b8165584 100644 --- a/gcc/fortran/intrinsic.c +++ b/gcc/fortran/intrinsic.c @@ -3292,7 +3292,7 @@ keywords: if (f->actual != NULL) { - gfc_error ("Argument '%s' is appears twice in call to '%s' at %L", + gfc_error ("Argument '%s' appears twice in call to '%s' at %L", f->name, name, where); return FAILURE; } diff --git a/gcc/fortran/openmp.c b/gcc/fortran/openmp.c index d60121c5929..c00e1b41e28 100644 --- a/gcc/fortran/openmp.c +++ b/gcc/fortran/openmp.c @@ -1,5 +1,5 @@ /* OpenMP directive matching and resolving. - Copyright (C) 2005, 2006, 2007, 2008 + Copyright (C) 2005, 2006, 2007, 2008, 2010 Free Software Foundation, Inc. Contributed by Jakub Jelinek @@ -1367,7 +1367,6 @@ gfc_resolve_omp_parallel_blocks (gfc_code *code, gfc_namespace *ns) void gfc_resolve_do_iterator (gfc_code *code, gfc_symbol *sym) { - struct omp_context *ctx; int i = omp_current_do_collapse; gfc_code *c = omp_current_do_code; @@ -1386,21 +1385,21 @@ gfc_resolve_do_iterator (gfc_code *code, gfc_symbol *sym) c = c->block->next; } - for (ctx = omp_current_ctx; ctx; ctx = ctx->previous) - { - if (pointer_set_contains (ctx->sharing_clauses, sym)) - continue; + if (omp_current_ctx == NULL) + return; - if (! pointer_set_insert (ctx->private_iterators, sym)) - { - gfc_omp_clauses *omp_clauses = ctx->code->ext.omp_clauses; - gfc_namelist *p; + if (pointer_set_contains (omp_current_ctx->sharing_clauses, sym)) + return; - p = gfc_get_namelist (); - p->sym = sym; - p->next = omp_clauses->lists[OMP_LIST_PRIVATE]; - omp_clauses->lists[OMP_LIST_PRIVATE] = p; - } + if (! pointer_set_insert (omp_current_ctx->private_iterators, sym)) + { + gfc_omp_clauses *omp_clauses = omp_current_ctx->code->ext.omp_clauses; + gfc_namelist *p; + + p = gfc_get_namelist (); + p->sym = sym; + p->next = omp_clauses->lists[OMP_LIST_PRIVATE]; + omp_clauses->lists[OMP_LIST_PRIVATE] = p; } } diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c index 2831149c757..aeccffb60ca 100644 --- a/gcc/fortran/resolve.c +++ b/gcc/fortran/resolve.c @@ -3978,8 +3978,9 @@ compare_spec_to_ref (gfc_array_ref *ar) /* Resolve one part of an array index. */ -gfc_try -gfc_resolve_index (gfc_expr *index, int check_scalar) +static gfc_try +gfc_resolve_index_1 (gfc_expr *index, int check_scalar, + int force_index_integer_kind) { gfc_typespec ts; @@ -4007,7 +4008,8 @@ gfc_resolve_index (gfc_expr *index, int check_scalar) &index->where) == FAILURE) return FAILURE; - if (index->ts.kind != gfc_index_integer_kind + if ((index->ts.kind != gfc_index_integer_kind + && force_index_integer_kind) || index->ts.type != BT_INTEGER) { gfc_clear_ts (&ts); @@ -4020,6 +4022,14 @@ gfc_resolve_index (gfc_expr *index, int check_scalar) return SUCCESS; } +/* Resolve one part of an array index. */ + +gfc_try +gfc_resolve_index (gfc_expr *index, int check_scalar) +{ + return gfc_resolve_index_1 (index, check_scalar, 1); +} + /* Resolve a dim argument to an intrinsic function. */ gfc_try @@ -4144,7 +4154,10 @@ resolve_array_ref (gfc_array_ref *ar) { check_scalar = ar->dimen_type[i] == DIMEN_RANGE; - if (gfc_resolve_index (ar->start[i], check_scalar) == FAILURE) + /* Do not force gfc_index_integer_kind for the start. We can + do fine with any integer kind. This avoids temporary arrays + created for indexing with a vector. */ + if (gfc_resolve_index_1 (ar->start[i], check_scalar, 0) == FAILURE) return FAILURE; if (gfc_resolve_index (ar->end[i], check_scalar) == FAILURE) return FAILURE; @@ -10617,7 +10630,9 @@ ensure_not_abstract_walker (gfc_symbol* sub, gfc_symtree* st) { gfc_symtree* overriding; overriding = gfc_find_typebound_proc (sub, NULL, st->name, true, NULL); - gcc_assert (overriding && overriding->n.tb); + if (!overriding) + return FAILURE; + gcc_assert (overriding->n.tb); if (overriding->n.tb->deferred) { gfc_error ("Derived-type '%s' declared at %L must be ABSTRACT because" @@ -10784,8 +10799,12 @@ resolve_fl_derived (gfc_symbol *sym) /* Copy char length. */ if (ifc->ts.type == BT_CHARACTER && ifc->ts.u.cl) { - c->ts.u.cl = gfc_new_charlen (sym->ns, ifc->ts.u.cl); - gfc_expr_replace_comp (c->ts.u.cl->length, c); + gfc_charlen *cl = gfc_new_charlen (sym->ns, ifc->ts.u.cl); + gfc_expr_replace_comp (cl->length, c); + if (cl->length && !cl->resolved + && gfc_resolve_expr (cl->length) == FAILURE) + return FAILURE; + c->ts.u.cl = cl; } } else if (c->ts.interface->name[0] != '\0') @@ -11298,6 +11317,9 @@ resolve_symbol (gfc_symbol *sym) { sym->ts.u.cl = gfc_new_charlen (sym->ns, ifc->ts.u.cl); gfc_expr_replace_symbols (sym->ts.u.cl->length, sym); + if (sym->ts.u.cl->length && !sym->ts.u.cl->resolved + && gfc_resolve_expr (sym->ts.u.cl->length) == FAILURE) + return; } } else if (sym->ts.interface->name[0] != '\0') diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c index a880f0efe61..199eb23b6ac 100644 --- a/gcc/fortran/trans-array.c +++ b/gcc/fortran/trans-array.c @@ -2434,6 +2434,7 @@ gfc_conv_array_index_offset (gfc_se * se, gfc_ss_info * info, int dim, int i, gfc_conv_array_data (desc)); index = gfc_build_array_ref (data, index, NULL); index = gfc_evaluate_now (index, &se->pre); + index = fold_convert (gfc_array_index_type, index); /* Do any bounds checking on the final info->descriptor index. */ index = gfc_trans_array_bound_check (se, info->descriptor, @@ -3365,13 +3366,15 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop) if (size[n]) { tmp3 = fold_build2 (NE_EXPR, boolean_type_node, tmp, size[n]); - asprintf (&msg, "%s, size mismatch for dimension %d " - "of array '%s' (%%ld/%%ld)", gfc_msg_bounds, + asprintf (&msg, "Array bound mismatch for dimension %d " + "of array '%s' (%%ld/%%ld)", info->dim[n]+1, ss->expr->symtree->name); + gfc_trans_runtime_check (true, false, tmp3, &inner, &ss->expr->where, msg, fold_convert (long_integer_type_node, tmp), fold_convert (long_integer_type_node, size[n])); + gfc_free (msg); } else @@ -4632,15 +4635,26 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body) { /* Check (ubound(a) - lbound(a) == ubound(b) - lbound(b)). */ char * msg; + tree temp; - tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, - ubound, lbound); - stride2 = fold_build2 (MINUS_EXPR, gfc_array_index_type, + temp = fold_build2 (MINUS_EXPR, gfc_array_index_type, + ubound, lbound); + temp = fold_build2 (PLUS_EXPR, gfc_array_index_type, + gfc_index_one_node, temp); + + stride2 = fold_build2 (MINUS_EXPR, gfc_array_index_type, dubound, dlbound); - tmp = fold_build2 (NE_EXPR, gfc_array_index_type, tmp, stride2); - asprintf (&msg, "%s for dimension %d of array '%s'", - gfc_msg_bounds, n+1, sym->name); - gfc_trans_runtime_check (true, false, tmp, &block, &loc, msg); + stride2 = fold_build2 (PLUS_EXPR, gfc_array_index_type, + gfc_index_one_node, stride2); + + tmp = fold_build2 (NE_EXPR, gfc_array_index_type, temp, stride2); + asprintf (&msg, "Dimension %d of array '%s' has extent " + "%%ld instead of %%ld", n+1, sym->name); + + gfc_trans_runtime_check (true, false, tmp, &block, &loc, msg, + fold_convert (long_integer_type_node, temp), + fold_convert (long_integer_type_node, stride2)); + gfc_free (msg); } } diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c index 2545ad2a320..11a75b46033 100644 --- a/gcc/fortran/trans-decl.c +++ b/gcc/fortran/trans-decl.c @@ -3477,7 +3477,8 @@ gfc_create_module_variable (gfc_symbol * sym) tree length; length = sym->ts.u.cl->backend_decl; - if (!INTEGER_CST_P (length)) + gcc_assert (length || sym->attr.proc_pointer); + if (length && !INTEGER_CST_P (length)) { pushdecl (length); rest_of_decl_compilation (length, 1, 0); diff --git a/gcc/fortran/trans.c b/gcc/fortran/trans.c index c1993f90ddd..21c56045a44 100644 --- a/gcc/fortran/trans.c +++ b/gcc/fortran/trans.c @@ -47,7 +47,6 @@ along with GCC; see the file COPYING3. If not see static gfc_file *gfc_current_backend_file; -const char gfc_msg_bounds[] = N_("Array bound mismatch"); const char gfc_msg_fault[] = N_("Array reference out of bounds"); const char gfc_msg_wrong_return[] = N_("Incorrect function return value"); diff --git a/gcc/fortran/trans.h b/gcc/fortran/trans.h index 782ff1d9e78..91f1b7784d1 100644 --- a/gcc/fortran/trans.h +++ b/gcc/fortran/trans.h @@ -773,7 +773,6 @@ void gfc_apply_interface_mapping (gfc_interface_mapping *, /* Standard error messages used in all the trans-*.c files. */ -extern const char gfc_msg_bounds[]; extern const char gfc_msg_fault[]; extern const char gfc_msg_wrong_return[]; diff --git a/gcc/gcc.c b/gcc/gcc.c index d2190533796..a25077e24f7 100644 --- a/gcc/gcc.c +++ b/gcc/gcc.c @@ -7495,7 +7495,7 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n" fuse_linker_plugin + strlen (fuse_linker_plugin), 0)) { linker_plugin_file_spec = find_a_file (&exec_prefixes, - "liblto_plugin.so", X_OK, + "liblto_plugin.so", R_OK, false); if (!linker_plugin_file_spec) fatal ("-fuse-linker-plugin, but liblto_plugin.so not found"); diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 270475c0c6c..ab076348be0 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -159,7 +159,7 @@ maybe_fold_offset_to_array_ref (location_t loc, tree base, tree offset, return NULL_TREE; /* Use signed size type for intermediate computation on the index. */ - idx_type = signed_type_for (size_type_node); + idx_type = ssizetype; /* If OFFSET and ELT_OFFSET are zero, we don't care about the size of the element type (so we can use the alignment if it's not constant). diff --git a/gcc/gimple.h b/gcc/gimple.h index 18ebbb1e560..3daaa9e3c40 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -964,6 +964,7 @@ extern bool gimple_ior_addresses_taken (bitmap, gimple); extern tree create_tmp_var_raw (tree, const char *); extern tree create_tmp_var_name (const char *); extern tree create_tmp_var (tree, const char *); +extern tree create_tmp_reg (tree, const char *); extern tree get_initialized_tmp_var (tree, gimple_seq *, gimple_seq *); extern tree get_formal_tmp_var (tree, gimple_seq *); extern void declare_vars (tree, gimple, bool); diff --git a/gcc/gimplify.c b/gcc/gimplify.c index de3da28fa1c..ad101d52d00 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -508,6 +508,23 @@ create_tmp_var (tree type, const char *prefix) return tmp_var; } +/* Create a new temporary variable declaration of type TYPE by calling + create_tmp_var and if TYPE is a vector or a complex number, mark the new + temporary as gimple register. */ + +tree +create_tmp_reg (tree type, const char *prefix) +{ + tree tmp; + + tmp = create_tmp_var (type, prefix); + if (TREE_CODE (type) == COMPLEX_TYPE + || TREE_CODE (type) == VECTOR_TYPE) + DECL_GIMPLE_REG_P (tmp) = 1; + + return tmp; +} + /* Create a temporary with a name derived from VAL. Subroutine of lookup_tmp_var; nobody else should call this function. */ @@ -1219,10 +1236,7 @@ gimplify_return_expr (tree stmt, gimple_seq *pre_p) result = gimplify_ctxp->return_temp; else { - result = create_tmp_var (TREE_TYPE (result_decl), NULL); - if (TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (result) = 1; + result = create_tmp_reg (TREE_TYPE (result_decl), NULL); /* ??? With complex control flow (usually involving abnormal edges), we can wind up warning about an uninitialized value for this. Due @@ -6351,9 +6365,7 @@ gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p) tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr))); tree tmp_load; - tmp_load = create_tmp_var (type, NULL); - if (TREE_CODE (type) == COMPLEX_TYPE || TREE_CODE (type) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (tmp_load) = 1; + tmp_load = create_tmp_reg (type, NULL); if (goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0) return GS_ERROR; @@ -7828,11 +7840,8 @@ gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p) } if (need_temp) { - tree temp = create_tmp_var (TREE_TYPE (lhs), NULL); + tree temp = create_tmp_reg (TREE_TYPE (lhs), NULL); - if (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (lhs)) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (temp) = 1; if (TREE_CODE (orig_lhs) == SSA_NAME) orig_lhs = SSA_NAME_VAR (orig_lhs); diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c index 1f4773a6d45..dcf44b8facf 100644 --- a/gcc/ifcvt.c +++ b/gcc/ifcvt.c @@ -1440,8 +1440,9 @@ noce_try_cmove_arith (struct noce_if_info *if_info) if insn_rtx_cost can't be estimated. */ if (insn_a) { - insn_cost = insn_rtx_cost (PATTERN (insn_a), - optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn_a))); + insn_cost + = insn_rtx_cost (PATTERN (insn_a), + optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn_a))); if (insn_cost == 0 || insn_cost > COSTS_N_INSNS (if_info->branch_cost)) return FALSE; } @@ -1450,8 +1451,9 @@ noce_try_cmove_arith (struct noce_if_info *if_info) if (insn_b) { - insn_cost += insn_rtx_cost (PATTERN (insn_b), - optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn_b))); + insn_cost + += insn_rtx_cost (PATTERN (insn_b), + optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn_b))); if (insn_cost == 0 || insn_cost > COSTS_N_INSNS (if_info->branch_cost)) return FALSE; } @@ -2579,7 +2581,8 @@ noce_process_if_block (struct noce_if_info *if_info) REGS. COND is the condition we will test. */ static int -check_cond_move_block (basic_block bb, rtx *vals, VEC (int, heap) **regs, rtx cond) +check_cond_move_block (basic_block bb, rtx *vals, VEC (int, heap) **regs, + rtx cond) { rtx insn; @@ -2743,7 +2746,8 @@ cond_move_process_if_block (struct noce_if_info *if_info) /* Make sure the blocks are suitable. */ if (!check_cond_move_block (then_bb, then_vals, &then_regs, cond) - || (else_bb && !check_cond_move_block (else_bb, else_vals, &else_regs, cond))) + || (else_bb + && !check_cond_move_block (else_bb, else_vals, &else_regs, cond))) { VEC_free (int, heap, then_regs); VEC_free (int, heap, else_regs); @@ -2859,8 +2863,7 @@ cond_move_process_if_block (struct noce_if_info *if_info) Return TRUE if we were successful at converting the block. */ static int -noce_find_if_block (basic_block test_bb, - edge then_edge, edge else_edge, +noce_find_if_block (basic_block test_bb, edge then_edge, edge else_edge, int pass) { basic_block then_bb, else_bb, join_bb; @@ -2941,9 +2944,7 @@ noce_find_if_block (basic_block test_bb, return FALSE; /* If this is not a standard conditional jump, we can't parse it. */ - cond = noce_get_condition (jump, - &cond_earliest, - then_else_reversed); + cond = noce_get_condition (jump, &cond_earliest, then_else_reversed); if (!cond) return FALSE; @@ -3135,7 +3136,7 @@ find_if_header (basic_block test_bb, int pass) /* Otherwise this must be a multiway branch of some sort. */ return NULL; - memset (&ce_info, '\0', sizeof (ce_info)); + memset (&ce_info, 0, sizeof (ce_info)); ce_info.test_bb = test_bb; ce_info.then_bb = then_edge->dest; ce_info.else_bb = else_edge->dest; @@ -3145,11 +3146,12 @@ find_if_header (basic_block test_bb, int pass) IFCVT_INIT_EXTRA_FIELDS (&ce_info); #endif - if (! reload_completed + if (!reload_completed && noce_find_if_block (test_bb, then_edge, else_edge, pass)) goto success; - if (targetm.have_conditional_execution () && reload_completed + if (reload_completed + && targetm.have_conditional_execution () && cond_exec_find_if_block (&ce_info)) goto success; @@ -3159,7 +3161,7 @@ find_if_header (basic_block test_bb, int pass) goto success; if (dom_info_state (CDI_POST_DOMINATORS) >= DOM_NO_FAST_QUERY - && (! targetm.have_conditional_execution () || reload_completed)) + && (reload_completed || !targetm.have_conditional_execution ())) { if (find_if_case_1 (test_bb, then_edge, else_edge)) goto success; @@ -3265,8 +3267,8 @@ cond_exec_find_if_block (struct ce_if_block * ce_info) ce_info->last_test_bb = test_bb; /* We only ever should get here after reload, - and only if we have conditional execution. */ - gcc_assert (targetm.have_conditional_execution () && reload_completed); + and if we have conditional execution. */ + gcc_assert (reload_completed && targetm.have_conditional_execution ()); /* Discover if any fall through predecessors of the current test basic block were && tests (which jump to the else block) or || tests (which jump to @@ -3347,7 +3349,8 @@ cond_exec_find_if_block (struct ce_if_block * ce_info) if (EDGE_COUNT (then_bb->succs) > 0 && (!single_succ_p (then_bb) || (single_succ_edge (then_bb)->flags & EDGE_COMPLEX) - || (epilogue_completed && tablejump_p (BB_END (then_bb), NULL, NULL)))) + || (epilogue_completed + && tablejump_p (BB_END (then_bb), NULL, NULL)))) return FALSE; /* If the THEN block has no successors, conditional execution can still @@ -3393,8 +3396,9 @@ cond_exec_find_if_block (struct ce_if_block * ce_info) else if (single_succ_p (else_bb) && single_succ (then_bb) == single_succ (else_bb) && single_pred_p (else_bb) - && ! (single_succ_edge (else_bb)->flags & EDGE_COMPLEX) - && ! (epilogue_completed && tablejump_p (BB_END (else_bb), NULL, NULL))) + && !(single_succ_edge (else_bb)->flags & EDGE_COMPLEX) + && !(epilogue_completed + && tablejump_p (BB_END (else_bb), NULL, NULL))) join_bb = single_succ (else_bb); /* Otherwise it is not an IF-THEN or IF-THEN-ELSE combination. */ @@ -3990,7 +3994,7 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb, that any registers modified are dead at the branch site. */ rtx insn, cond, prev; - bitmap merge_set, test_live, test_set; + bitmap merge_set, merge_set_noclobber, test_live, test_set; unsigned i, fail = 0; bitmap_iterator bi; @@ -4026,11 +4030,14 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb, /* Collect: MERGE_SET = set of registers set in MERGE_BB + MERGE_SET_NOCLOBBER = like MERGE_SET, but only includes registers + that are really set, not just clobbered. TEST_LIVE = set of registers live at EARLIEST - TEST_SET = set of registers set between EARLIEST and the - end of the block. */ + TEST_SET = set of registers set between EARLIEST and the + end of the block. */ merge_set = BITMAP_ALLOC (®_obstack); + merge_set_noclobber = BITMAP_ALLOC (®_obstack); test_live = BITMAP_ALLOC (®_obstack); test_set = BITMAP_ALLOC (®_obstack); @@ -4047,13 +4054,8 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb, { if (NONDEBUG_INSN_P (insn)) { - unsigned int uid = INSN_UID (insn); - df_ref *def_rec; - for (def_rec = DF_INSN_UID_DEFS (uid); *def_rec; def_rec++) - { - df_ref def = *def_rec; - bitmap_set_bit (merge_set, DF_REF_REGNO (def)); - } + df_simulate_find_defs (insn, merge_set); + df_simulate_find_noclobber_defs (insn, merge_set_noclobber); } } @@ -4061,7 +4063,7 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb, hard registers before reload. */ if (SMALL_REGISTER_CLASSES && ! reload_completed) { - EXECUTE_IF_SET_IN_BITMAP (merge_set, 0, i, bi) + EXECUTE_IF_SET_IN_BITMAP (merge_set_noclobber, 0, i, bi) { if (i < FIRST_PSEUDO_REGISTER && ! fixed_regs[i] @@ -4081,7 +4083,7 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb, { if (INSN_P (insn)) { - df_simulate_find_defs (insn, test_set); + df_simulate_find_noclobber_defs (insn, test_set); df_simulate_one_insn_backwards (test_bb, insn, test_live); } prev = PREV_INSN (insn); @@ -4090,16 +4092,19 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb, } /* We can perform the transformation if - MERGE_SET & (TEST_SET | TEST_LIVE) + MERGE_SET_NOCLOBBER & TEST_SET + and + MERGE_SET & TEST_LIVE) and TEST_SET & DF_LIVE_IN (merge_bb) are empty. */ - if (bitmap_intersect_p (test_set, merge_set) + if (bitmap_intersect_p (test_set, merge_set_noclobber) || bitmap_intersect_p (test_live, merge_set) || bitmap_intersect_p (test_set, df_get_live_in (merge_bb))) fail = 1; + BITMAP_FREE (merge_set_noclobber); BITMAP_FREE (merge_set); BITMAP_FREE (test_live); BITMAP_FREE (test_set); diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index 527c0c42530..ca7c0e6b7c9 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -1344,7 +1344,8 @@ struct ipa_opt_pass_d pass_ipa_cp = ipcp_generate_summary, /* generate_summary */ ipcp_write_summary, /* write_summary */ ipcp_read_summary, /* read_summary */ - NULL, /* function_read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ lto_ipa_fixup_call_notes, /* stmt_fixup */ 0, /* TODOs */ NULL, /* function_transform */ diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c index 601695a3fda..fbd695d129c 100644 --- a/gcc/ipa-inline.c +++ b/gcc/ipa-inline.c @@ -1024,8 +1024,9 @@ cgraph_decide_inlining_of_small_functions (void) " Estimated growth after inlined into all callees is %+i insns.\n" " Estimated badness is %i, frequency %.2f.\n", cgraph_node_name (edge->caller), - gimple_filename ((const_gimple) edge->call_stmt), - gimple_lineno ((const_gimple) edge->call_stmt), + flag_wpa ? "unknown" + : gimple_filename ((const_gimple) edge->call_stmt), + flag_wpa ? -1 : gimple_lineno ((const_gimple) edge->call_stmt), cgraph_estimate_growth (edge->callee), badness, edge->frequency / (double)CGRAPH_FREQ_BASE); @@ -1200,8 +1201,9 @@ cgraph_decide_inlining_of_small_functions (void) " Estimated growth after inlined into all callees is %+i insns.\n" " Estimated badness is %i, frequency %.2f.\n", cgraph_node_name (edge->caller), - gimple_filename ((const_gimple) edge->call_stmt), - gimple_lineno ((const_gimple) edge->call_stmt), + flag_wpa ? "unknown" + : gimple_filename ((const_gimple) edge->call_stmt), + flag_wpa ? -1 : gimple_lineno ((const_gimple) edge->call_stmt), cgraph_estimate_growth (edge->callee), badness, edge->frequency / (double)CGRAPH_FREQ_BASE); @@ -1416,13 +1418,14 @@ cgraph_decide_inlining (void) if (cgraph_check_inline_limits (node->callers->caller, node, &reason, false)) { + struct cgraph_node *caller = node->callers->caller; cgraph_mark_inline (node->callers); if (dump_file) fprintf (dump_file, " Inlined into %s which now has %i size" " for a net change of %+i size.\n", - cgraph_node_name (node->callers->caller), - node->callers->caller->global.size, + cgraph_node_name (caller), + caller->global.size, overall_size - old_size); } else @@ -1667,6 +1670,17 @@ cgraph_early_inlining (void) } else { + if (lookup_attribute ("flatten", + DECL_ATTRIBUTES (node->decl)) != NULL) + { + if (dump_file) + fprintf (dump_file, + "Flattening %s\n", cgraph_node_name (node)); + cgraph_flatten (node); + timevar_push (TV_INTEGRATION); + todo |= optimize_inline_calls (current_function_decl); + timevar_pop (TV_INTEGRATION); + } /* We iterate incremental inlining to get trivial cases of indirect inlining. */ while (iterations < PARAM_VALUE (PARAM_EARLY_INLINER_MAX_ITERATIONS) @@ -2121,7 +2135,8 @@ struct ipa_opt_pass_d pass_ipa_inline = inline_generate_summary, /* generate_summary */ inline_write_summary, /* write_summary */ inline_read_summary, /* read_summary */ - NULL, /* function_read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ lto_ipa_fixup_call_notes, /* stmt_fixup */ 0, /* TODOs */ inline_transform, /* function_transform */ diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c index c6d58b1d452..af00175124d 100644 --- a/gcc/ipa-prop.c +++ b/gcc/ipa-prop.c @@ -1260,6 +1260,10 @@ ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED) static void ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED) { + /* During IPA-CP updating we can be called on not-yet analyze clones. */ + if (VEC_length (ipa_node_params_t, ipa_node_params_vector) + <= (unsigned)node->uid) + return; ipa_free_node_params_substructures (IPA_NODE_REF (node)); } @@ -1700,7 +1704,7 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt, if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr))) expr = fold_convert (ptrtype, expr); expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr, - build_int_cst (size_type_node, + build_int_cst (sizetype, adj->offset / BITS_PER_UNIT)); if (!adj->by_ref) expr = fold_build1 (INDIRECT_REF, adj->type, expr); diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c index 719bef6b768..4d0df50ac63 100644 --- a/gcc/ipa-pure-const.c +++ b/gcc/ipa-pure-const.c @@ -1104,7 +1104,8 @@ struct ipa_opt_pass_d pass_ipa_pure_const = generate_summary, /* generate_summary */ pure_const_write_summary, /* write_summary */ pure_const_read_summary, /* read_summary */ - NULL, /* function_read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ NULL, /* stmt_fixup */ 0, /* TODOs */ NULL, /* function_transform */ diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c index 9eac3b10e82..7183e65a7fd 100644 --- a/gcc/ipa-reference.c +++ b/gcc/ipa-reference.c @@ -1514,7 +1514,8 @@ struct ipa_opt_pass_d pass_ipa_reference = generate_summary, /* generate_summary */ ipa_reference_write_summary, /* write_summary */ ipa_reference_read_summary, /* read_summary */ - NULL, /* function_read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ NULL, /* stmt_fixup */ 0, /* TODOs */ NULL, /* function_transform */ diff --git a/gcc/ipa.c b/gcc/ipa.c index d559ab2f285..3a5ef16d2be 100644 --- a/gcc/ipa.c +++ b/gcc/ipa.c @@ -271,6 +271,8 @@ cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file) node->analyzed = false; node->local.inlinable = false; } + else + gcc_assert (!clone->in_other_partition); cgraph_node_remove_callees (node); if (node->prev_sibling_clone) node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone; @@ -574,7 +576,8 @@ struct ipa_opt_pass_d pass_ipa_whole_program_visibility = NULL, /* generate_summary */ NULL, /* write_summary */ NULL, /* read_summary */ - NULL, /* function_read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ NULL, /* stmt_fixup */ 0, /* TODOs */ NULL, /* function_transform */ diff --git a/gcc/ira-color.c b/gcc/ira-color.c index f507db18aee..e01a6abdb47 100644 --- a/gcc/ira-color.c +++ b/gcc/ira-color.c @@ -2786,7 +2786,9 @@ allocno_reload_assign (ira_allocno_t a, HARD_REG_SET forbidden_regs) int hard_regno; enum reg_class cover_class; int regno = ALLOCNO_REGNO (a); + HARD_REG_SET saved; + COPY_HARD_REG_SET (saved, ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a)); IOR_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a), forbidden_regs); if (! flag_caller_saves && ALLOCNO_CALLS_CROSSED_NUM (a) != 0) IOR_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a), call_used_reg_set); @@ -2830,7 +2832,7 @@ allocno_reload_assign (ira_allocno_t a, HARD_REG_SET forbidden_regs) } else if (internal_flag_ira_verbose > 3 && ira_dump_file != NULL) fprintf (ira_dump_file, "\n"); - + COPY_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a), saved); return reg_renumber[regno] >= 0; } diff --git a/gcc/ira-lives.c b/gcc/ira-lives.c index 09316b510f2..7ced1a7a73d 100644 --- a/gcc/ira-lives.c +++ b/gcc/ira-lives.c @@ -805,6 +805,9 @@ ira_implicitly_set_insn_hard_regs (HARD_REG_SET *set) ? GENERAL_REGS : REG_CLASS_FROM_CONSTRAINT (c, p)); if (cl != NO_REGS + /* There is no register pressure problem if all of the + regs in this class are fixed. */ + && ira_available_class_regs[cl] != 0 && (ira_available_class_regs[cl] <= ira_reg_class_nregs[cl][mode])) IOR_HARD_REG_SET (*set, reg_class_contents[cl]); diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index f1a60807436..b88bd1974ed 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,8 @@ +2010-04-18 Eric Botcazou + + * decl.c (java_init_decl_processing): Remove argument in call to + initialize_sizetypes + 2010-04-07 Jakub Jelinek * exception.cc (_Jv_Throw): Avoid set but not used warning. diff --git a/gcc/java/decl.c b/gcc/java/decl.c index c593b53df5c..4cd4d9668dc 100644 --- a/gcc/java/decl.c +++ b/gcc/java/decl.c @@ -579,7 +579,7 @@ java_init_decl_processing (void) TREE_TYPE (error_mark_node) = error_mark_node; /* Create sizetype first - needed for other types. */ - initialize_sizetypes (false); + initialize_sizetypes (); byte_type_node = make_signed_type (8); pushdecl (build_decl (BUILTINS_LOCATION, diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c index b3143da8e38..fff6ff800f3 100644 --- a/gcc/lambda-code.c +++ b/gcc/lambda-code.c @@ -150,6 +150,17 @@ static lambda_lattice lambda_lattice_compute_base (lambda_loopnest, static bool can_convert_to_perfect_nest (struct loop *); +/* Create a new lambda loop in LAMBDA_OBSTACK. */ + +static lambda_loop +lambda_loop_new (struct obstack * lambda_obstack) +{ + lambda_loop result = (lambda_loop) + obstack_alloc (lambda_obstack, sizeof (struct lambda_loop_s)); + memset (result, 0, sizeof (struct lambda_loop_s)); + return result; +} + /* Create a new lambda body vector. */ lambda_body_vector @@ -157,7 +168,8 @@ lambda_body_vector_new (int size, struct obstack * lambda_obstack) { lambda_body_vector ret; - ret = (lambda_body_vector)obstack_alloc (lambda_obstack, sizeof (*ret)); + ret = (lambda_body_vector) obstack_alloc (lambda_obstack, + sizeof (*ret)); LBV_COEFFICIENTS (ret) = lambda_vector_new (size); LBV_SIZE (ret) = size; LBV_DENOMINATOR (ret) = 1; @@ -367,9 +379,10 @@ lambda_lattice_new (int depth, int invariants, struct obstack * lambda_obstack) { lambda_lattice ret = (lambda_lattice)obstack_alloc (lambda_obstack, sizeof (*ret)); - LATTICE_BASE (ret) = lambda_matrix_new (depth, depth); + LATTICE_BASE (ret) = lambda_matrix_new (depth, depth, lambda_obstack); LATTICE_ORIGIN (ret) = lambda_vector_new (depth); - LATTICE_ORIGIN_INVARIANTS (ret) = lambda_matrix_new (depth, invariants); + LATTICE_ORIGIN_INVARIANTS (ret) = lambda_matrix_new (depth, invariants, + lambda_obstack); LATTICE_DIMENSION (ret) = depth; LATTICE_INVARIANTS (ret) = invariants; return ret; @@ -500,15 +513,15 @@ compute_nest_using_fourier_motzkin (int size, lambda_vector swapvector, a1; int newsize; - A1 = lambda_matrix_new (128, depth); - B1 = lambda_matrix_new (128, invariants); + A1 = lambda_matrix_new (128, depth, lambda_obstack); + B1 = lambda_matrix_new (128, invariants, lambda_obstack); a1 = lambda_vector_new (128); auxillary_nest = lambda_loopnest_new (depth, invariants, lambda_obstack); for (i = depth - 1; i >= 0; i--) { - loop = lambda_loop_new (); + loop = lambda_loop_new (lambda_obstack); LN_LOOPS (auxillary_nest)[i] = loop; LL_STEP (loop) = 1; @@ -654,12 +667,12 @@ lambda_compute_auxillary_space (lambda_loopnest nest, /* Unfortunately, we can't know the number of constraints we'll have ahead of time, but this should be enough even in ridiculous loop nest cases. We must not go over this limit. */ - A = lambda_matrix_new (128, depth); - B = lambda_matrix_new (128, invariants); + A = lambda_matrix_new (128, depth, lambda_obstack); + B = lambda_matrix_new (128, invariants, lambda_obstack); a = lambda_vector_new (128); - A1 = lambda_matrix_new (128, depth); - B1 = lambda_matrix_new (128, invariants); + A1 = lambda_matrix_new (128, depth, lambda_obstack); + B1 = lambda_matrix_new (128, invariants, lambda_obstack); a1 = lambda_vector_new (128); /* Store the bounds in the equation matrix A, constant vector a, and @@ -754,11 +767,11 @@ lambda_compute_auxillary_space (lambda_loopnest nest, /* Now compute the auxiliary space bounds by first inverting U, multiplying it by A1, then performing Fourier-Motzkin. */ - invertedtrans = lambda_matrix_new (depth, depth); + invertedtrans = lambda_matrix_new (depth, depth, lambda_obstack); /* Compute the inverse of U. */ lambda_matrix_inverse (LTM_MATRIX (trans), - invertedtrans, depth); + invertedtrans, depth, lambda_obstack); /* A = A1 inv(U). */ lambda_matrix_mult (A1, invertedtrans, A, size, depth, depth); @@ -795,18 +808,19 @@ lambda_compute_target_space (lambda_loopnest auxillary_nest, depth = LN_DEPTH (auxillary_nest); invariants = LN_INVARIANTS (auxillary_nest); - inverse = lambda_matrix_new (depth, depth); - determinant = lambda_matrix_inverse (LTM_MATRIX (H), inverse, depth); + inverse = lambda_matrix_new (depth, depth, lambda_obstack); + determinant = lambda_matrix_inverse (LTM_MATRIX (H), inverse, depth, + lambda_obstack); /* H1 is H excluding its diagonal. */ - H1 = lambda_matrix_new (depth, depth); + H1 = lambda_matrix_new (depth, depth, lambda_obstack); lambda_matrix_copy (LTM_MATRIX (H), H1, depth, depth); for (i = 0; i < depth; i++) H1[i][i] = 0; /* Computes the linear offsets of the loop bounds. */ - target = lambda_matrix_new (depth, depth); + target = lambda_matrix_new (depth, depth, lambda_obstack); lambda_matrix_mult (H1, inverse, target, depth, depth, depth); target_nest = lambda_loopnest_new (depth, invariants, lambda_obstack); @@ -815,7 +829,7 @@ lambda_compute_target_space (lambda_loopnest auxillary_nest, { /* Get a new loop structure. */ - target_loop = lambda_loop_new (); + target_loop = lambda_loop_new (lambda_obstack); LN_LOOPS (target_nest)[i] = target_loop; /* Computes the gcd of the coefficients of the linear part. */ @@ -982,7 +996,9 @@ lambda_compute_target_space (lambda_loopnest auxillary_nest, result. */ static lambda_vector -lambda_compute_step_signs (lambda_trans_matrix trans, lambda_vector stepsigns) +lambda_compute_step_signs (lambda_trans_matrix trans, + lambda_vector stepsigns, + struct obstack * lambda_obstack) { lambda_matrix matrix, H; int size; @@ -992,7 +1008,7 @@ lambda_compute_step_signs (lambda_trans_matrix trans, lambda_vector stepsigns) matrix = LTM_MATRIX (trans); size = LTM_ROWSIZE (trans); - H = lambda_matrix_new (size, size); + H = lambda_matrix_new (size, size, lambda_obstack); newsteps = lambda_vector_new (size); lambda_vector_copy (stepsigns, newsteps, size); @@ -1067,7 +1083,7 @@ lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans, /* Compute the lattice base. */ lattice = lambda_lattice_compute_base (nest, lambda_obstack); - trans1 = lambda_trans_matrix_new (depth, depth); + trans1 = lambda_trans_matrix_new (depth, depth, lambda_obstack); /* Multiply the transformation matrix by the lattice base. */ @@ -1075,25 +1091,27 @@ lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans, LTM_MATRIX (trans1), depth, depth, depth); /* Compute the Hermite normal form for the new transformation matrix. */ - H = lambda_trans_matrix_new (depth, depth); - U = lambda_trans_matrix_new (depth, depth); + H = lambda_trans_matrix_new (depth, depth, lambda_obstack); + U = lambda_trans_matrix_new (depth, depth, lambda_obstack); lambda_matrix_hermite (LTM_MATRIX (trans1), depth, LTM_MATRIX (H), LTM_MATRIX (U)); /* Compute the auxiliary loop nest's space from the unimodular portion. */ - auxillary_nest = lambda_compute_auxillary_space (nest, U, lambda_obstack); + auxillary_nest = lambda_compute_auxillary_space (nest, U, + lambda_obstack); /* Compute the loop step signs from the old step signs and the transformation matrix. */ - stepsigns = lambda_compute_step_signs (trans1, stepsigns); + stepsigns = lambda_compute_step_signs (trans1, stepsigns, + lambda_obstack); /* Compute the target loop nest space from the auxiliary nest and the lower triangular matrix H. */ target_nest = lambda_compute_target_space (auxillary_nest, H, stepsigns, lambda_obstack); origin = lambda_vector_new (depth); - origin_invariants = lambda_matrix_new (depth, invariants); + origin_invariants = lambda_matrix_new (depth, invariants, lambda_obstack); lambda_matrix_vector_mult (LTM_MATRIX (trans), depth, depth, LATTICE_ORIGIN (lattice), origin); lambda_matrix_mult (LTM_MATRIX (trans), LATTICE_ORIGIN_INVARIANTS (lattice), @@ -1424,7 +1442,7 @@ gcc_loop_to_lambda_loop (struct loop *loop, int depth, return NULL; } - lloop = lambda_loop_new (); + lloop = lambda_loop_new (lambda_obstack); LL_STEP (lloop) = stepint; LL_LOWER_BOUND (lloop) = lbound; LL_UPPER_BOUND (lloop) = ubound; @@ -1702,7 +1720,7 @@ lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest, tree oldiv; gimple_stmt_iterator bsi; - transform = lambda_trans_matrix_inverse (transform); + transform = lambda_trans_matrix_inverse (transform, lambda_obstack); if (dump_file) { @@ -2801,9 +2819,12 @@ av_for_af (tree access_fun, lambda_vector cy, struct access_matrix *am) static bool build_access_matrix (data_reference_p data_reference, - VEC (tree, heap) *parameters, VEC (loop_p, heap) *nest) + VEC (tree, heap) *parameters, + VEC (loop_p, heap) *nest, + struct obstack * lambda_obstack) { - struct access_matrix *am = GGC_NEW (struct access_matrix); + struct access_matrix *am = (struct access_matrix *) + obstack_alloc(lambda_obstack, sizeof (struct access_matrix)); unsigned i, ndim = DR_NUM_DIMENSIONS (data_reference); unsigned nivs = VEC_length (loop_p, nest); unsigned lambda_nb_columns; @@ -2835,13 +2856,14 @@ build_access_matrix (data_reference_p data_reference, bool lambda_compute_access_matrices (VEC (data_reference_p, heap) *datarefs, VEC (tree, heap) *parameters, - VEC (loop_p, heap) *nest) + VEC (loop_p, heap) *nest, + struct obstack * lambda_obstack) { data_reference_p dataref; unsigned ix; for (ix = 0; VEC_iterate (data_reference_p, datarefs, ix, dataref); ix++) - if (!build_access_matrix (dataref, parameters, nest)) + if (!build_access_matrix (dataref, parameters, nest, lambda_obstack)) return false; return true; diff --git a/gcc/lambda-mat.c b/gcc/lambda-mat.c index fb9098b20e1..50fdb699925 100644 --- a/gcc/lambda-mat.c +++ b/gcc/lambda-mat.c @@ -27,18 +27,16 @@ along with GCC; see the file COPYING3. If not see #include "tree-flow.h" #include "lambda.h" -static void lambda_matrix_get_column (lambda_matrix, int, int, - lambda_vector); - /* Allocate a matrix of M rows x N cols. */ lambda_matrix -lambda_matrix_new (int m, int n) +lambda_matrix_new (int m, int n, struct obstack * lambda_obstack) { lambda_matrix mat; int i; - mat = GGC_NEWVEC (lambda_vector, m); + mat = (lambda_matrix) obstack_alloc (lambda_obstack, + sizeof (lambda_vector *) * m); for (i = 0; i < m; i++) mat[i] = lambda_vector_new (n); @@ -165,19 +163,6 @@ lambda_matrix_mult (lambda_matrix mat1, lambda_matrix mat2, } } -/* Get column COL from the matrix MAT and store it in VEC. MAT has - N rows, so the length of VEC must be N. */ - -static void -lambda_matrix_get_column (lambda_matrix mat, int n, int col, - lambda_vector vec) -{ - int i; - - for (i = 0; i < n; i++) - vec[i] = mat[i][col]; -} - /* Delete rows r1 to r2 (not including r2). */ void @@ -307,10 +292,12 @@ lambda_matrix_col_mc (lambda_matrix mat, int m, int c1, int const1) When MAT is a 2 x 2 matrix, we don't go through the whole process, because it is easily inverted by inspection and it is a very common case. */ -static int lambda_matrix_inverse_hard (lambda_matrix, lambda_matrix, int); +static int lambda_matrix_inverse_hard (lambda_matrix, lambda_matrix, int, + struct obstack *); int -lambda_matrix_inverse (lambda_matrix mat, lambda_matrix inv, int n) +lambda_matrix_inverse (lambda_matrix mat, lambda_matrix inv, int n, + struct obstack * lambda_obstack) { if (n == 2) { @@ -335,20 +322,21 @@ lambda_matrix_inverse (lambda_matrix mat, lambda_matrix inv, int n) return det; } else - return lambda_matrix_inverse_hard (mat, inv, n); + return lambda_matrix_inverse_hard (mat, inv, n, lambda_obstack); } /* If MAT is not a special case, invert it the hard way. */ static int -lambda_matrix_inverse_hard (lambda_matrix mat, lambda_matrix inv, int n) +lambda_matrix_inverse_hard (lambda_matrix mat, lambda_matrix inv, int n, + struct obstack * lambda_obstack) { lambda_vector row; lambda_matrix temp; int i, j; int determinant; - temp = lambda_matrix_new (n, n); + temp = lambda_matrix_new (n, n, lambda_obstack); lambda_matrix_copy (mat, temp, n, n); lambda_matrix_id (inv, n); @@ -592,45 +580,6 @@ lambda_matrix_first_nz_vec (lambda_matrix mat, int rowsize, int colsize, return rowsize; } -/* Calculate the projection of E sub k to the null space of B. */ - -void -lambda_matrix_project_to_null (lambda_matrix B, int rowsize, - int colsize, int k, lambda_vector x) -{ - lambda_matrix M1, M2, M3, I; - int determinant; - - /* Compute c(I-B^T inv(B B^T) B) e sub k. */ - - /* M1 is the transpose of B. */ - M1 = lambda_matrix_new (colsize, colsize); - lambda_matrix_transpose (B, M1, rowsize, colsize); - - /* M2 = B * B^T */ - M2 = lambda_matrix_new (colsize, colsize); - lambda_matrix_mult (B, M1, M2, rowsize, colsize, rowsize); - - /* M3 = inv(M2) */ - M3 = lambda_matrix_new (colsize, colsize); - determinant = lambda_matrix_inverse (M2, M3, rowsize); - - /* M2 = B^T (inv(B B^T)) */ - lambda_matrix_mult (M1, M3, M2, colsize, rowsize, rowsize); - - /* M1 = B^T (inv(B B^T)) B */ - lambda_matrix_mult (M2, B, M1, colsize, rowsize, colsize); - lambda_matrix_negate (M1, M1, colsize, colsize); - - I = lambda_matrix_new (colsize, colsize); - lambda_matrix_id (I, colsize); - - lambda_matrix_add_mc (I, determinant, M1, 1, M2, colsize, colsize); - - lambda_matrix_get_column (M2, colsize, k - 1, x); - -} - /* Multiply a vector VEC by a matrix MAT. MAT is an M*N matrix, and VEC is a vector with length N. The result is stored in DEST which must be a vector of length M. */ diff --git a/gcc/lambda-trans.c b/gcc/lambda-trans.c index d34a63e2e86..0cf1db96fa6 100644 --- a/gcc/lambda-trans.c +++ b/gcc/lambda-trans.c @@ -31,12 +31,14 @@ along with GCC; see the file COPYING3. If not see /* Allocate a new transformation matrix. */ lambda_trans_matrix -lambda_trans_matrix_new (int colsize, int rowsize) +lambda_trans_matrix_new (int colsize, int rowsize, + struct obstack * lambda_obstack) { lambda_trans_matrix ret; - ret = GGC_NEW (struct lambda_trans_matrix_s); - LTM_MATRIX (ret) = lambda_matrix_new (rowsize, colsize); + ret = (lambda_trans_matrix) + obstack_alloc (lambda_obstack, sizeof (struct lambda_trans_matrix_s)); + LTM_MATRIX (ret) = lambda_matrix_new (rowsize, colsize, lambda_obstack); LTM_ROWSIZE (ret) = rowsize; LTM_COLSIZE (ret) = colsize; LTM_DENOMINATOR (ret) = 1; @@ -57,14 +59,16 @@ lambda_trans_matrix_id_p (lambda_trans_matrix mat) /* Compute the inverse of the transformation matrix MAT. */ lambda_trans_matrix -lambda_trans_matrix_inverse (lambda_trans_matrix mat) +lambda_trans_matrix_inverse (lambda_trans_matrix mat, + struct obstack * lambda_obstack) { lambda_trans_matrix inverse; int determinant; - inverse = lambda_trans_matrix_new (LTM_ROWSIZE (mat), LTM_COLSIZE (mat)); + inverse = lambda_trans_matrix_new (LTM_ROWSIZE (mat), LTM_COLSIZE (mat), + lambda_obstack); determinant = lambda_matrix_inverse (LTM_MATRIX (mat), LTM_MATRIX (inverse), - LTM_ROWSIZE (mat)); + LTM_ROWSIZE (mat), lambda_obstack); LTM_DENOMINATOR (inverse) = determinant; return inverse; } diff --git a/gcc/lambda.h b/gcc/lambda.h index 189c1fc50b3..c819027f582 100644 --- a/gcc/lambda.h +++ b/gcc/lambda.h @@ -156,11 +156,9 @@ struct loop; bool perfect_nest_p (struct loop *); void print_lambda_loopnest (FILE *, lambda_loopnest, char); -#define lambda_loop_new() (lambda_loop) ggc_alloc_cleared (sizeof (struct lambda_loop_s)) - void print_lambda_loop (FILE *, lambda_loop, int, int, char); -lambda_matrix lambda_matrix_new (int, int); +lambda_matrix lambda_matrix_new (int, int, struct obstack *); void lambda_matrix_id (lambda_matrix, int); bool lambda_matrix_id_p (lambda_matrix, int); @@ -182,7 +180,7 @@ void lambda_matrix_col_exchange (lambda_matrix, int, int, int); void lambda_matrix_col_add (lambda_matrix, int, int, int, int); void lambda_matrix_col_negate (lambda_matrix, int, int); void lambda_matrix_col_mc (lambda_matrix, int, int, int); -int lambda_matrix_inverse (lambda_matrix, lambda_matrix, int); +int lambda_matrix_inverse (lambda_matrix, lambda_matrix, int, struct obstack *); void lambda_matrix_hermite (lambda_matrix, int, lambda_matrix, lambda_matrix); void lambda_matrix_left_hermite (lambda_matrix, int, int, lambda_matrix, lambda_matrix); void lambda_matrix_right_hermite (lambda_matrix, int, int, lambda_matrix, lambda_matrix); @@ -191,13 +189,14 @@ void lambda_matrix_project_to_null (lambda_matrix, int, int, int, lambda_vector); void print_lambda_matrix (FILE *, lambda_matrix, int, int); -lambda_trans_matrix lambda_trans_matrix_new (int, int); +lambda_trans_matrix lambda_trans_matrix_new (int, int, struct obstack *); bool lambda_trans_matrix_nonsingular_p (lambda_trans_matrix); bool lambda_trans_matrix_fullrank_p (lambda_trans_matrix); int lambda_trans_matrix_rank (lambda_trans_matrix); lambda_trans_matrix lambda_trans_matrix_basis (lambda_trans_matrix); lambda_trans_matrix lambda_trans_matrix_padding (lambda_trans_matrix); -lambda_trans_matrix lambda_trans_matrix_inverse (lambda_trans_matrix); +lambda_trans_matrix lambda_trans_matrix_inverse (lambda_trans_matrix, + struct obstack *); void print_lambda_trans_matrix (FILE *, lambda_trans_matrix); void lambda_matrix_vector_mult (lambda_matrix, int, int, lambda_vector, lambda_vector); diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c index e3deb9c8b06..cb87143e4ac 100644 --- a/gcc/lto-cgraph.c +++ b/gcc/lto-cgraph.c @@ -164,6 +164,23 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge, bitpack_delete (bp); } +/* Return true when node is reachable from other partition. */ + +static bool +reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set) +{ + struct cgraph_edge *e; + if (node->needed) + return true; + if (!node->analyzed) + return false; + if (node->global.inlined_to) + return false; + for (e = node->callers; e; e = e->next_caller) + if (!cgraph_node_in_set_p (e->caller, set)) + return true; + return false; +} /* Output the cgraph NODE to OB. ENCODER is used to find the reference number of NODE->inlined_to. SET is the set of nodes we @@ -183,6 +200,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node, unsigned local, externally_visible, inlinable, analyzed; bool boundary_p, wrote_decl_p; intptr_t ref; + bool in_other_partition = false; boundary_p = !cgraph_node_in_set_p (node, set); wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl)); @@ -228,19 +246,17 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node, local static nodes to prevent clashes with other local statics. */ if (boundary_p) { - /* Inline clones can not be part of boundary. */ - gcc_assert (!node->global.inlined_to); - local = 0; - externally_visible = 1; - inlinable = 0; + /* Inline clones can not be part of boundary. + gcc_assert (!node->global.inlined_to); + + FIXME: At the moment they can be, when partition contains an inline + clone that is clone of inline clone from outside partition. We can + reshape the clone tree and make other tree to be the root, but it + needs a bit extra work and will be promplty done by cgraph_remove_node + after reading back. */ + in_other_partition = 1; analyzed = 0; } - else if (lto_forced_extern_inline_p (node->decl)) - { - local = 1; - externally_visible = 0; - inlinable = 1; - } lto_output_uleb128_stream (ob->main_stream, wrote_decl_p); @@ -263,8 +279,10 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node, bp_pack_value (bp, node->address_taken, 1); bp_pack_value (bp, node->abstract_and_needed, 1); bp_pack_value (bp, node->reachable, 1); + bp_pack_value (bp, analyzed && reachable_from_other_partition_p (node, set), 1); bp_pack_value (bp, node->lowered, 1); bp_pack_value (bp, analyzed, 1); + bp_pack_value (bp, in_other_partition, 1); bp_pack_value (bp, node->process, 1); bp_pack_value (bp, node->alias, 1); bp_pack_value (bp, node->finalized_by_frontend, 1); @@ -306,7 +324,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node, lto_output_sleb128_stream (ob->main_stream, node->global.estimated_growth); lto_output_uleb128_stream (ob->main_stream, node->global.inlined); - if (node->same_comdat_group) + if (node->same_comdat_group && !boundary_p) { ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group); gcc_assert (ref != LCC_NOT_FOUND); @@ -371,6 +389,15 @@ output_profile_summary (struct lto_simple_output_block *ob) lto_output_uleb128_stream (ob->main_stream, 0); } +/* Add NODE into encoder as well as nodes it is cloned from. + Do it in a way so clones appear first. */ +static void +add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node) +{ + if (node->clone_of) + add_node_to (encoder, node->clone_of); + lto_cgraph_encoder_encode (encoder, node); +} /* Output the part of the cgraph in SET. */ @@ -404,7 +431,7 @@ output_cgraph (cgraph_node_set set) for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) { node = csi_node (csi); - lto_cgraph_encoder_encode (encoder, node); + add_node_to (encoder, node); } /* Go over all the nodes again to include callees that are not in @@ -419,34 +446,14 @@ output_cgraph (cgraph_node_set set) { /* We should have moved all the inlines. */ gcc_assert (!callee->global.inlined_to); - lto_cgraph_encoder_encode (encoder, callee); - /* Also with each included function include all other functions - in the same comdat group. */ - if (callee->same_comdat_group) - { - struct cgraph_node *next; - for (next = callee->same_comdat_group; - next != callee; - next = next->same_comdat_group) - if (!cgraph_node_in_set_p (next, set)) - lto_cgraph_encoder_encode (encoder, next); - } + add_node_to (encoder, callee); } } - /* Also with each included function include all other functions - in the same comdat group. */ - if (node->same_comdat_group) - { - struct cgraph_node *next; - for (next = node->same_comdat_group; - next != node; - next = next->same_comdat_group) - if (!cgraph_node_in_set_p (next, set)) - lto_cgraph_encoder_encode (encoder, next); - } } - /* Write out the nodes. */ + /* Write out the nodes. We must first output a node and then its clones, + otherwise at a time reading back the node there would be nothing to clone + from. */ n_nodes = lto_cgraph_encoder_size (encoder); for (i = 0; i < n_nodes; i++) { @@ -530,8 +537,10 @@ input_overwrite_node (struct lto_file_decl_data *file_data, node->address_taken = bp_unpack_value (bp, 1); node->abstract_and_needed = bp_unpack_value (bp, 1); node->reachable = bp_unpack_value (bp, 1); + node->reachable_from_other_partition = bp_unpack_value (bp, 1); node->lowered = bp_unpack_value (bp, 1); node->analyzed = bp_unpack_value (bp, 1); + node->in_other_partition = bp_unpack_value (bp, 1); node->process = bp_unpack_value (bp, 1); node->alias = bp_unpack_value (bp, 1); node->finalized_by_frontend = bp_unpack_value (bp, 1); diff --git a/gcc/lto-section-in.c b/gcc/lto-section-in.c index 9277b12005f..4f2ae4ff37f 100644 --- a/gcc/lto-section-in.c +++ b/gcc/lto-section-in.c @@ -55,7 +55,6 @@ const char *lto_section_name[LTO_N_SECTION_TYPES] = "ipa_pure_const", "ipa_reference", "symtab", - "wpa_fixup", "opts" }; diff --git a/gcc/lto-section-out.c b/gcc/lto-section-out.c index 895394f3a1b..d603c069ed4 100644 --- a/gcc/lto-section-out.c +++ b/gcc/lto-section-out.c @@ -50,48 +50,6 @@ static VEC(lto_out_decl_state_ptr, heap) *decl_state_stack; generate the decl directory later. */ VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states; - -/* Bitmap indexed by DECL_UID to indicate if a function needs to be - forced extern inline. */ -static bitmap forced_extern_inline; - -/* Initialize states for determining which function decls to be ouput - as extern inline, regardless of the decls' own attributes. */ - -void -lto_new_extern_inline_states (void) -{ - forced_extern_inline = lto_bitmap_alloc (); -} - -/* Releasing resources use for states to determine which function decls - to be ouput as extern inline */ - -void -lto_delete_extern_inline_states (void) -{ - lto_bitmap_free (forced_extern_inline); - forced_extern_inline = NULL; -} - -/* Force all the functions in DECLS to be output as extern inline. - DECLS is a bitmap indexed by DECL_UID. */ - -void -lto_force_functions_extern_inline (bitmap decls) -{ - bitmap_ior_into (forced_extern_inline, decls); -} - -/* Return true if FN_DECL is a function which should be emitted as - extern inline. */ - -bool -lto_forced_extern_inline_p (tree fn_decl) -{ - return bitmap_bit_p (forced_extern_inline, DECL_UID (fn_decl)); -} - /* Returns a hash code for P. */ hashval_t diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c index f375282beac..c9220254db9 100644 --- a/gcc/lto-streamer-out.c +++ b/gcc/lto-streamer-out.c @@ -2147,7 +2147,8 @@ struct ipa_opt_pass_d pass_ipa_lto_gimple_out = NULL, /* generate_summary */ lto_output, /* write_summary */ NULL, /* read_summary */ - NULL, /* function_read_summary */ + lto_output, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ NULL, /* stmt_fixup */ 0, /* TODOs */ NULL, /* function_transform */ @@ -2565,7 +2566,8 @@ struct ipa_opt_pass_d pass_ipa_lto_finish_out = NULL, /* generate_summary */ produce_asm_for_decls, /* write_summary */ NULL, /* read_summary */ - NULL, /* function_read_summary */ + produce_asm_for_decls, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ NULL, /* stmt_fixup */ 0, /* TODOs */ NULL, /* function_transform */ diff --git a/gcc/lto-streamer.c b/gcc/lto-streamer.c index 0b44845bceb..46d61548e12 100644 --- a/gcc/lto-streamer.c +++ b/gcc/lto-streamer.c @@ -169,9 +169,6 @@ lto_get_section_name (int section_type, const char *name) case LTO_section_ipa_reference: return concat (LTO_SECTION_NAME_PREFIX, ".reference", NULL); - case LTO_section_wpa_fixup: - return concat (LTO_SECTION_NAME_PREFIX, ".wpa_fixup", NULL); - case LTO_section_opts: return concat (LTO_SECTION_NAME_PREFIX, ".opts", NULL); diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h index 6ac8ef8a2a8..a9544b5642a 100644 --- a/gcc/lto-streamer.h +++ b/gcc/lto-streamer.h @@ -770,10 +770,6 @@ extern void lto_push_out_decl_state (struct lto_out_decl_state *); extern struct lto_out_decl_state *lto_pop_out_decl_state (void); extern void lto_record_function_out_decl_state (tree, struct lto_out_decl_state *); -extern void lto_new_extern_inline_states (void); -extern void lto_delete_extern_inline_states (void); -extern void lto_force_functions_extern_inline (bitmap decls); -extern bool lto_forced_extern_inline_p (tree fn_decl); /* In lto-streamer.c. */ diff --git a/gcc/lto-wpa-fixup.c b/gcc/lto-wpa-fixup.c deleted file mode 100644 index 0839aa9df9a..00000000000 --- a/gcc/lto-wpa-fixup.c +++ /dev/null @@ -1,282 +0,0 @@ -/* Write and read any fix-up information generated by the WPA mode. - - Copyright 2009 Free Software Foundation, Inc. - Contributed by Doug Kwan - -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 -. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "toplev.h" -#include "tree.h" -#include "expr.h" -#include "flags.h" -#include "cgraph.h" -#include "function.h" -#include "diagnostic.h" -#include "vec.h" -#include "bitmap.h" -#include "timevar.h" -#include "tree-flow.h" -#include "tree-pass.h" -#include "lto-streamer.h" - -/* LTO fix-up. - - In WPA mode, LTO cannot access function bodies. Some modifications in - IR require additional updates in function bodies, which are not possible - in WPA mode. So we write out information about these modifications for - LTRANS to fix up the function bodies accordingly. */ - -/* The vectors records function DECLs having multiple copies with different - exception throwing attributes. We do not mark a DECL if all copies of it - have the same exception throwing attribute. */ -static bitmap lto_nothrow_fndecls; - -/* We need to fix up GIMPLE bodies due to changes in exception setting. - Consider this example: - - a.h: - class a { - public: - a(); - ~a(); - }; - - main.cc: - #include "a.h" - - int - main (int argc, char **argv) - { - a x; - return 0; - } - - a.cc: - #include "a.h" - a::a() {} - a::~a() {} - - When main.cc is compiled, gcc only sees the constructor declaration, so - the constructor and hence the call to it are marked as exception throwing. - When a.cc is compiled, the body of the constructor is available and is - obviously not exception throwing. Thus DECL of a::a in a.o has the NOTHROW - attribute. When LTO runs, two DECLs of a::a with different exception - attributes are merged. We want the merged DECL to be not exception - throwing for better generated code. To do that, we need to fix up any - function calls that have been marked as exception throwing. */ - -/* Fix up all the call statements whose target fndecls might have changed - to NOTHROW. Note that this problem is not WPA specific. We can also - run into this problem in normal LTO with multiple input files. */ - -void -lto_fixup_nothrow_decls (void) -{ - struct cgraph_node *node; - struct cgraph_edge *edge; - struct function *caller_function; - gimple call_stmt; - - /* Quit if we are in WPA mode or have not marked any DECLs. */ - if (flag_wpa || !lto_nothrow_fndecls) - return; - - /* For each node that has been marked, go over all call edges to it. */ - for (node = cgraph_nodes; node; node = node->next) - if (bitmap_bit_p (lto_nothrow_fndecls, DECL_UID (node->decl))) - { - gcc_assert (TREE_NOTHROW (node->decl)); - for (edge = node->callers; edge; edge = edge->next_caller) - { - caller_function = DECL_STRUCT_FUNCTION (edge->caller->decl); - call_stmt = edge->call_stmt; - gcc_assert (call_stmt); - if (lookup_stmt_eh_lp_fn (caller_function, call_stmt) != 0) - remove_stmt_from_eh_lp_fn (caller_function, call_stmt); - } - } -} - -/* Mark FNDECL as becoming not exception throwing. */ - -void -lto_mark_nothrow_fndecl (tree fndecl) -{ - gcc_assert (TREE_CODE (fndecl) == FUNCTION_DECL); - if (!lto_nothrow_fndecls) - lto_nothrow_fndecls = lto_bitmap_alloc (); - - bitmap_set_bit (lto_nothrow_fndecls, DECL_UID (fndecl)); -} - -/* Write out fix-up information. Currently the only WPA fix-up - information is the list of DECLs marked as not exception throwing. SET - is a cgraph node set whose fix-up information is to be written. */ - -static void -lto_output_wpa_fixup (cgraph_node_set set) -{ - struct lto_simple_output_block *ob; - cgraph_node_set_iterator csi; - tree fndecl; - bitmap seen_decls; - VEC(tree, heap) *decls = NULL; - unsigned HOST_WIDE_INT i, count; - - ob = lto_create_simple_output_block (LTO_section_wpa_fixup); - - /* Accumulate the DECLs to be written out. Since we do not want - duplicates, we need to use a bitmap and a vector to save the - DECLs we want. Note that we need to check if lto_nothrow_fndecls - is NULL. This happens when no DECL has been marked. */ - seen_decls = lto_bitmap_alloc (); - if (lto_nothrow_fndecls) - for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) - { - struct cgraph_edge *e; - struct cgraph_node *n; - - n = csi_node (csi); - fndecl = n->decl; - - /* Check if the N's function is in the set of nothrow functions. */ - if (!bitmap_bit_p (seen_decls, DECL_UID (fndecl))) - { - bitmap_set_bit (seen_decls, (DECL_UID (fndecl))); - if (bitmap_bit_p (lto_nothrow_fndecls, DECL_UID (fndecl))) - VEC_safe_push (tree, heap, decls, fndecl); - } - - /* Now check the callees and also add them if they are nothrow. This - is needed because node N may end up in a different partition than - its callees. In which case, when the file holding N is compiled, - the calls it makes to nothrow functions will not be fixed up, - causing verification issues. */ - for (e = n->callees; e; e = e->next_callee) - { - fndecl = e->callee->decl; - if (!bitmap_bit_p (seen_decls, DECL_UID (fndecl))) - { - bitmap_set_bit (seen_decls, (DECL_UID (fndecl))); - if (bitmap_bit_p (lto_nothrow_fndecls, DECL_UID (fndecl))) - VEC_safe_push (tree, heap, decls, fndecl); - } - } - } - - /* Write out number of DECLs, followed by the DECLs. */ - count = VEC_length (tree, decls); - lto_output_uleb128_stream (ob->main_stream, count); - for (i = 0; i < count; i++) - { - fndecl = VEC_index (tree, decls, i); - lto_output_fn_decl_index (ob->decl_state, ob->main_stream, fndecl); - } - - /* Release resources. */ - lto_destroy_simple_output_block (ob); - VEC_free(tree, heap, decls); - lto_bitmap_free (seen_decls); -} - -/* Read in WPA fix-up information from one file. FILE_DATA points to - DECL information of the file where as IB is the input block for the - WPA fix-up section. */ - -static void -lto_input_wpa_fixup_1 (struct lto_file_decl_data *file_data, - struct lto_input_block *ib) -{ - unsigned HOST_WIDE_INT i, count, decl_index; - tree fndecl; - - count = lto_input_uleb128 (ib); - for (i = 0; i < count; i++) - { - decl_index = lto_input_uleb128 (ib); - fndecl = lto_file_decl_data_get_fn_decl (file_data, decl_index); - lto_mark_nothrow_fndecl (fndecl); - } -} - -/* Read in WPA fix-up information. */ - -static void -lto_input_wpa_fixup (void) -{ - struct lto_file_decl_data ** file_data_vec - = lto_get_file_decl_data (); - struct lto_file_decl_data * file_data; - int i = 0; - - /* Fix up information is only used in LTRANS mode. */ - if (!flag_ltrans) - return; - - while ((file_data = file_data_vec[i++])) - { - const char *data; - size_t len; - struct lto_input_block *ib - = lto_create_simple_input_block (file_data, LTO_section_wpa_fixup, - &data, &len); - - lto_input_wpa_fixup_1 (file_data, ib); - lto_destroy_simple_input_block (file_data, LTO_section_wpa_fixup, ib, - data, len); - } -} - -/* Gate function for all lto streaming passes. */ - -static bool -gate_wpa_fixup (void) -{ - return (flag_wpa || flag_ltrans) && gate_lto_out (); -} - -struct ipa_opt_pass_d pass_ipa_lto_wpa_fixup = -{ - { - IPA_PASS, - "lto_wpa_fixup", /* name */ - gate_wpa_fixup, /* gate */ - NULL, /* execute */ - NULL, /* sub */ - NULL, /* next */ - 0, /* static_pass_number */ - TV_WHOPR_WPA_FIXUP, /* tv_id */ - 0, /* properties_required */ - 0, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - TODO_dump_func /* todo_flags_finish */ - }, - NULL, /* generate_summary */ - lto_output_wpa_fixup, /* write_summary */ - lto_input_wpa_fixup, /* read_summary */ - NULL, /* function_read_summary */ - NULL, /* stmt_fixup */ - 0, /* TODOs */ - NULL, /* function_transform */ - NULL /* variable_transform */ -}; - diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index 20b89d69761..2ce58d742f3 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,3 +1,31 @@ +2010-04-21 Jan Hubicka + + * lto.c (lto_fixup_tree): Do not call wpa fixup. + (materialize_cgraph): Likewise. + +2010-04-21 Jan Hubicka + + * lto.c (lto_wpa_write_files): Update. + (read_cgraph_and_symbols): Be more verbose. + (materialize_cgraph): Likewise. + (do_whole_program_analysis): Likewise. + +2010-04-21 Jan Hubicka + + * lto.c (globalize_cross_file_statics): When function has address taken, + it needs to be public. + +2010-04-20 Jan Hubicka + + * lto.c (lto_add_inline_clones): Do not track inlined_decls. + (lto_add_all_inlinees): Likewise. + (lto_wpa_write_files): Likewise. + +2010-04-18 Eric Botcazou + + * lto-lang.c (lto_init): Remove second argument in call to + build_common_tree_nodes. + 2010-04-16 Rainer Orth * lto-elf.c [!HAVE_ELF_GETSHDRSTRNDX] (elf_getshdrstrndx): New diff --git a/gcc/lto/lto-lang.c b/gcc/lto/lto-lang.c index 05577a29371..aea5ab22d35 100644 --- a/gcc/lto/lto-lang.c +++ b/gcc/lto/lto-lang.c @@ -1039,7 +1039,7 @@ lto_init (void) linemap_add (line_table, LC_RENAME, 0, NULL, 0); /* Create the basic integer types. */ - build_common_tree_nodes (flag_signed_char, /*signed_sizetype=*/false); + build_common_tree_nodes (flag_signed_char); /* Share char_type_node with whatever would be the default for the target. char_type_node will be used for internal types such as diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c index de53a09f87d..115d1cc5678 100644 --- a/gcc/lto/lto.c +++ b/gcc/lto/lto.c @@ -554,6 +554,10 @@ lto_1_to_1_map (void) for (node = cgraph_nodes; node; node = node->next) { + /* We will get proper partition based on function they are inlined to or + cloned from. */ + if (node->global.inlined_to || node->clone_of) + continue; /* We only need to partition the nodes that we read from the gimple bytecode files. */ file_data = node->local.lto_file_data; @@ -589,22 +593,19 @@ finish: static void lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node, - bitmap original_decls, bitmap inlined_decls) + bitmap original_decls) { struct cgraph_node *callee; struct cgraph_edge *edge; cgraph_node_set_add (set, node); - if (!bitmap_bit_p (original_decls, DECL_UID (node->decl))) - bitmap_set_bit (inlined_decls, DECL_UID (node->decl)); - /* Check to see if NODE has any inlined callee. */ for (edge = node->callees; edge != NULL; edge = edge->next_callee) { callee = edge->callee; if (callee->global.inlined_to != NULL) - lto_add_inline_clones (set, callee, original_decls, inlined_decls); + lto_add_inline_clones (set, callee, original_decls); } } @@ -612,14 +613,13 @@ lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node, information in the callgraph. Returns a bitmap of decls that have been inlined into SET indexed by UID. */ -static bitmap +static void lto_add_all_inlinees (cgraph_node_set set) { cgraph_node_set_iterator csi; struct cgraph_node *node; bitmap original_nodes = lto_bitmap_alloc (); bitmap original_decls = lto_bitmap_alloc (); - bitmap inlined_decls = lto_bitmap_alloc (); bool changed; /* We are going to iterate SET while adding to it, mark all original @@ -659,19 +659,17 @@ lto_add_all_inlinees (cgraph_node_set set) } while (changed); - /* Transitively add to SET all the inline clones for every node that - has been inlined. */ - for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) - { - node = csi_node (csi); - if (bitmap_bit_p (original_nodes, node->uid)) - lto_add_inline_clones (set, node, original_decls, inlined_decls); - } + /* Transitively add to SET all the inline clones for every node that + has been inlined. */ + for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) + { + node = csi_node (csi); + if (bitmap_bit_p (original_nodes, node->uid)) + lto_add_inline_clones (set, node, original_decls); + } lto_bitmap_free (original_nodes); lto_bitmap_free (original_decls); - - return inlined_decls; } /* Owing to inlining, we may need to promote a file-scope variable @@ -762,7 +760,8 @@ globalize_cross_file_statics (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, } else if (TREE_CODE (t) == FUNCTION_DECL && !TREE_PUBLIC (t)) { - if (!cgraph_node_in_set_p (cgraph_node (t), context->set)) + if (!cgraph_node_in_set_p (cgraph_node (t), context->set) + || cgraph_node (t)->address_taken) { /* This file-scope static function is reachable from a set which does not contain the function DECL. Make it global @@ -1000,8 +999,6 @@ lto_wpa_write_files (void) unsigned i, n_sets, last_out_file_ix, num_out_files; lto_file *file; cgraph_node_set set; - bitmap decls; - VEC(bitmap,heap) *inlined_decls = NULL; timevar_push (TV_WHOPR_WPA); @@ -1011,8 +1008,7 @@ lto_wpa_write_files (void) compiled by LTRANS. */ for (i = 0; VEC_iterate (cgraph_node_set, lto_cgraph_node_sets, i, set); i++) { - decls = lto_add_all_inlinees (set); - VEC_safe_push (bitmap, heap, inlined_decls, decls); + lto_add_all_inlinees (set); lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr, set->nodes); } @@ -1049,13 +1045,8 @@ lto_wpa_write_files (void) fatal_error ("lto_elf_file_open() failed"); lto_set_current_out_file (file); - lto_new_extern_inline_states (); - decls = VEC_index (bitmap, inlined_decls, i); - lto_force_functions_extern_inline (decls); - - ipa_write_summaries_of_cgraph_node_set (set); - lto_delete_extern_inline_states (); + ipa_write_optimization_summaries (set); lto_set_current_out_file (NULL); lto_elf_file_close (file); @@ -1068,10 +1059,6 @@ lto_wpa_write_files (void) output_files[last_out_file_ix] = NULL; - for (i = 0; VEC_iterate (bitmap, inlined_decls, i, decls); i++) - lto_bitmap_free (decls); - VEC_free (bitmap, heap, inlined_decls); - timevar_pop (TV_WHOPR_WPA_IO); return output_files; @@ -1574,28 +1561,6 @@ lto_fixup_tree (tree *tp, int *walk_subtrees, void *data) if (t != prevailing) { - if (TREE_CODE (t) == FUNCTION_DECL - && TREE_NOTHROW (prevailing) != TREE_NOTHROW (t)) - { - /* If the prevailing definition does not throw but the - declaration (T) was considered throwing, then we - simply add PREVAILING to the list of throwing - functions. However, if the opposite is true, then - the call to PREVAILING was generated assuming that - the function didn't throw, which means that CFG - cleanup may have removed surrounding try/catch - regions. - - Note that we currently accept these cases even when - they occur within a single file. It's certainly a - user error, but we silently allow the compiler to - remove surrounding try/catch regions. Perhaps we - could emit a warning here, instead of silently - accepting the conflicting declaration. */ - if (TREE_NOTHROW (prevailing)) - lto_mark_nothrow_fndecl (prevailing); - } - /* Also replace t with prevailing defintion. We don't want to insert the other defintion in the seen set as we want to replace all instances of it. */ @@ -1835,10 +1800,18 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) gcc_assert (num_objects == nfiles); } + if (!quiet_flag) + fprintf (stderr, "Reading object files:"); + /* Read all of the object files specified on the command line. */ for (i = 0, last_file_ix = 0; i < nfiles; ++i) { struct lto_file_decl_data *file_data = NULL; + if (!quiet_flag) + { + fprintf (stderr, " %s", fnames[i]); + fflush (stderr); + } current_lto_file = lto_elf_file_open (fnames[i], false); if (!current_lto_file) @@ -1865,9 +1838,15 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) /* Each pass will set the appropriate timer. */ timevar_pop (TV_IPA_LTO_DECL_IO); + if (!quiet_flag) + fprintf (stderr, "\nReading the callgraph\n"); + /* Read the callgraph. */ input_cgraph (); + if (!quiet_flag) + fprintf (stderr, "Merging declarations\n"); + /* Merge global decls. */ lto_symtab_merge_decls (); @@ -1875,25 +1854,21 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames) lto_fixup_decls (all_file_decl_data); free_gimple_type_tables (); + if (!quiet_flag) + fprintf (stderr, "Reading summaries\n"); + /* Read the IPA summary data. */ - ipa_read_summaries (); + if (flag_ltrans) + ipa_read_optimization_summaries (); + else + ipa_read_summaries (); /* Finally merge the cgraph according to the decl merging decisions. */ lto_symtab_merge_cgraph_nodes (); - /* Mark cgraph nodes needed in the merged cgraph - This normally happens in whole-program pass, but for - ltrans the pass was already run at WPA phase. - - FIXME: This is not valid way to do so; nodes can be needed - for non-obvious reasons. We should stream the flags from WPA - phase. */ if (flag_ltrans) for (node = cgraph_nodes; node; node = node->next) { - if (!node->global.inlined_to - && cgraph_decide_is_function_needed (node, node->decl)) - cgraph_mark_needed_node (node); /* FIXME: ipa_transforms_to_apply holds list of passes that have optimization summaries computed and needs to apply changes. At the moment WHOPR only supports inlining, so we can push it here by hand. In future we need to stream @@ -1932,6 +1907,11 @@ materialize_cgraph (void) unsigned i; timevar_id_t lto_timer; + if (!quiet_flag) + fprintf (stderr, + flag_wpa ? "Materializing decls:" : "Reading function bodies:"); + + /* Now that we have input the cgraph, we need to clear all of the aux nodes and read the functions if we are not running in WPA mode. */ timevar_push (TV_IPA_LTO_GIMPLE_IO); @@ -1950,6 +1930,7 @@ materialize_cgraph (void) if (node->local.lto_file_data && !DECL_IS_BUILTIN (node->decl)) { + announce_function (node->decl); lto_materialize_function (node); lto_stats.num_input_cgraph_nodes++; } @@ -1971,8 +1952,8 @@ materialize_cgraph (void) for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++) rest_of_decl_compilation (decl, 1, 0); - /* Fix up any calls to DECLs that have become not exception throwing. */ - lto_fixup_nothrow_decls (); + if (!quiet_flag) + fprintf (stderr, "\n"); timevar_pop (lto_timer); } @@ -1986,9 +1967,6 @@ do_whole_program_analysis (void) { char **output_files; size_t i; - struct cgraph_node *node; - - lto_1_to_1_map (); /* Note that since we are in WPA mode, materialize_cgraph will not actually read in all the function bodies. It only materializes @@ -1998,20 +1976,12 @@ do_whole_program_analysis (void) /* Reading in the cgraph uses different timers, start timing WPA now. */ timevar_push (TV_WHOPR_WPA); - /* FIXME lto. Hack. We should use the IPA passes. There are a - number of issues with this now. 1. There is no convenient way to - do this. 2. Some passes may depend on properties that requires - the function bodies to compute. */ cgraph_function_flags_ready = true; bitmap_obstack_initialize (NULL); ipa_register_cgraph_hooks (); + cgraph_state = CGRAPH_STATE_IPA_SSA; - /* Reset inlining information before running IPA inliner. */ - for (node = cgraph_nodes; node; node = node->next) - reset_inline_failed (node); - - /* FIXME lto. We should not call this function directly. */ - pass_ipa_inline.pass.execute (); + execute_ipa_pass_list (all_regular_ipa_passes); verify_cgraph (); bitmap_obstack_release (NULL); @@ -2019,7 +1989,16 @@ do_whole_program_analysis (void) /* We are about to launch the final LTRANS phase, stop the WPA timer. */ timevar_pop (TV_WHOPR_WPA); + lto_1_to_1_map (); + + if (!quiet_flag) + { + fprintf (stderr, "\nStreaming out"); + fflush (stderr); + } output_files = lto_wpa_write_files (); + if (!quiet_flag) + fprintf (stderr, "\n"); /* Show the LTO report before launching LTRANS. */ if (flag_lto_report) diff --git a/gcc/omp-low.c b/gcc/omp-low.c index 9ab5c5294ab..cc36cb51bc5 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -1433,10 +1433,6 @@ scan_sharing_clauses (tree clauses, omp_context *ctx) break; case OMP_CLAUSE_COPYPRIVATE: - if (ctx->outer) - scan_omp_op (&OMP_CLAUSE_DECL (c), ctx->outer); - /* FALLTHRU */ - case OMP_CLAUSE_COPYIN: decl = OMP_CLAUSE_DECL (c); by_ref = use_pointer_for_field (decl, NULL); @@ -2702,7 +2698,7 @@ lower_copyprivate_clauses (tree clauses, gimple_seq *slist, gimple_seq *rlist, for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c)) { - tree var, ref, x; + tree var, new_var, ref, x; bool by_ref; location_t clause_loc = OMP_CLAUSE_LOCATION (c); @@ -2713,17 +2709,29 @@ lower_copyprivate_clauses (tree clauses, gimple_seq *slist, gimple_seq *rlist, by_ref = use_pointer_for_field (var, NULL); ref = build_sender_ref (var, ctx); - x = lookup_decl_in_outer_ctx (var, ctx); - x = by_ref ? build_fold_addr_expr_loc (clause_loc, x) : x; + x = new_var = lookup_decl_in_outer_ctx (var, ctx); + if (by_ref) + { + x = build_fold_addr_expr_loc (clause_loc, new_var); + x = fold_convert_loc (clause_loc, TREE_TYPE (ref), x); + } gimplify_assign (ref, x, slist); - ref = build_receiver_ref (var, by_ref, ctx); + ref = build_receiver_ref (var, false, ctx); + if (by_ref) + { + ref = fold_convert_loc (clause_loc, + build_pointer_type (TREE_TYPE (new_var)), + ref); + ref = build_fold_indirect_ref_loc (clause_loc, ref); + } if (is_reference (var)) { + ref = fold_convert_loc (clause_loc, TREE_TYPE (new_var), ref); ref = build_fold_indirect_ref_loc (clause_loc, ref); - var = build_fold_indirect_ref_loc (clause_loc, var); + new_var = build_fold_indirect_ref_loc (clause_loc, new_var); } - x = lang_hooks.decls.omp_clause_assign_op (c, var, ref); + x = lang_hooks.decls.omp_clause_assign_op (c, new_var, ref); gimplify_and_add (x, rlist); } } diff --git a/gcc/optabs.c b/gcc/optabs.c index 555e2562a45..5a3e61092b9 100644 --- a/gcc/optabs.c +++ b/gcc/optabs.c @@ -2928,7 +2928,7 @@ expand_absneg_bit (enum rtx_code code, enum machine_mode mode, const struct real_format *fmt; int bitpos, word, nwords, i; enum machine_mode imode; - HOST_WIDE_INT hi, lo; + double_int mask; rtx temp, insns; /* The format has to have a simple sign bit. */ @@ -2964,18 +2964,9 @@ expand_absneg_bit (enum rtx_code code, enum machine_mode mode, nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD; } - if (bitpos < HOST_BITS_PER_WIDE_INT) - { - hi = 0; - lo = (HOST_WIDE_INT) 1 << bitpos; - } - else - { - hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT); - lo = 0; - } + mask = double_int_setbit (double_int_zero, bitpos); if (code == ABS) - lo = ~lo, hi = ~hi; + mask = double_int_not (mask); if (target == 0 || target == op0) target = gen_reg_rtx (mode); @@ -2993,7 +2984,7 @@ expand_absneg_bit (enum rtx_code code, enum machine_mode mode, { temp = expand_binop (imode, code == ABS ? and_optab : xor_optab, op0_piece, - immed_double_const (lo, hi, imode), + immed_double_int_const (mask, imode), targ_piece, 1, OPTAB_LIB_WIDEN); if (temp != targ_piece) emit_move_insn (targ_piece, temp); @@ -3011,7 +3002,7 @@ expand_absneg_bit (enum rtx_code code, enum machine_mode mode, { temp = expand_binop (imode, code == ABS ? and_optab : xor_optab, gen_lowpart (imode, op0), - immed_double_const (lo, hi, imode), + immed_double_int_const (mask, imode), gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN); target = lowpart_subreg_maybe_copy (mode, temp, imode); @@ -3562,7 +3553,7 @@ expand_copysign_absneg (enum machine_mode mode, rtx op0, rtx op1, rtx target, } else { - HOST_WIDE_INT hi, lo; + double_int mask; if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD) { @@ -3584,20 +3575,10 @@ expand_copysign_absneg (enum machine_mode mode, rtx op0, rtx op1, rtx target, op1 = operand_subword_force (op1, word, mode); } - if (bitpos < HOST_BITS_PER_WIDE_INT) - { - hi = 0; - lo = (HOST_WIDE_INT) 1 << bitpos; - } - else - { - hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT); - lo = 0; - } + mask = double_int_setbit (double_int_zero, bitpos); - sign = gen_reg_rtx (imode); sign = expand_binop (imode, and_optab, op1, - immed_double_const (lo, hi, imode), + immed_double_int_const (mask, imode), NULL_RTX, 1, OPTAB_LIB_WIDEN); } @@ -3641,7 +3622,7 @@ expand_copysign_bit (enum machine_mode mode, rtx op0, rtx op1, rtx target, int bitpos, bool op0_is_abs) { enum machine_mode imode; - HOST_WIDE_INT hi, lo; + double_int mask; int word, nwords, i; rtx temp, insns; @@ -3665,16 +3646,7 @@ expand_copysign_bit (enum machine_mode mode, rtx op0, rtx op1, rtx target, nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD; } - if (bitpos < HOST_BITS_PER_WIDE_INT) - { - hi = 0; - lo = (HOST_WIDE_INT) 1 << bitpos; - } - else - { - hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT); - lo = 0; - } + mask = double_int_setbit (double_int_zero, bitpos); if (target == 0 || target == op0 || target == op1) target = gen_reg_rtx (mode); @@ -3691,13 +3663,15 @@ expand_copysign_bit (enum machine_mode mode, rtx op0, rtx op1, rtx target, if (i == word) { if (!op0_is_abs) - op0_piece = expand_binop (imode, and_optab, op0_piece, - immed_double_const (~lo, ~hi, imode), - NULL_RTX, 1, OPTAB_LIB_WIDEN); + op0_piece + = expand_binop (imode, and_optab, op0_piece, + immed_double_int_const (double_int_not (mask), + imode), + NULL_RTX, 1, OPTAB_LIB_WIDEN); op1 = expand_binop (imode, and_optab, operand_subword_force (op1, i, mode), - immed_double_const (lo, hi, imode), + immed_double_int_const (mask, imode), NULL_RTX, 1, OPTAB_LIB_WIDEN); temp = expand_binop (imode, ior_optab, op0_piece, op1, @@ -3717,13 +3691,14 @@ expand_copysign_bit (enum machine_mode mode, rtx op0, rtx op1, rtx target, else { op1 = expand_binop (imode, and_optab, gen_lowpart (imode, op1), - immed_double_const (lo, hi, imode), + immed_double_int_const (mask, imode), NULL_RTX, 1, OPTAB_LIB_WIDEN); op0 = gen_lowpart (imode, op0); if (!op0_is_abs) op0 = expand_binop (imode, and_optab, op0, - immed_double_const (~lo, ~hi, imode), + immed_double_int_const (double_int_not (mask), + imode), NULL_RTX, 1, OPTAB_LIB_WIDEN); temp = expand_binop (imode, ior_optab, op0, op1, diff --git a/gcc/optabs.h b/gcc/optabs.h index 0161d3e6d3b..0b72a516274 100644 --- a/gcc/optabs.h +++ b/gcc/optabs.h @@ -771,6 +771,9 @@ extern void expand_fix (rtx, rtx, int); /* Generate code for float to integral conversion. */ extern bool expand_sfix_optab (rtx, rtx, convert_optab); +/* Generate code for a widening multiply. */ +extern rtx expand_widening_mult (enum machine_mode, rtx, rtx, rtx, int, optab); + /* Return tree if target supports vector operations for COND_EXPR. */ bool expand_vec_cond_expr_p (tree, enum machine_mode); diff --git a/gcc/opts.c b/gcc/opts.c index 19d56348e2e..ce45e1cb0d5 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -1120,6 +1120,15 @@ decode_options (unsigned int argc, const char **argv) if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH)) PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40; } + if (flag_wpa || flag_ltrans) + { + /* These passes are not WHOPR compatible yet. */ + flag_ipa_cp = 0; + flag_ipa_reference = 0; + flag_ipa_type_escape = 0; + flag_ipa_pta = 0; + flag_ipa_struct_reorg = 0; + } if (flag_lto || flag_whopr) { diff --git a/gcc/passes.c b/gcc/passes.c index cbd605fb430..a6e5af50841 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -814,7 +814,6 @@ init_optimization_passes (void) p = &all_lto_gen_passes; NEXT_PASS (pass_ipa_lto_gimple_out); - NEXT_PASS (pass_ipa_lto_wpa_fixup); NEXT_PASS (pass_ipa_lto_finish_out); /* This must be the last LTO pass. */ *p = NULL; @@ -944,6 +943,7 @@ init_optimization_passes (void) NEXT_PASS (pass_forwprop); NEXT_PASS (pass_phiopt); NEXT_PASS (pass_fold_builtins); + NEXT_PASS (pass_optimize_widening_mul); NEXT_PASS (pass_tail_calls); NEXT_PASS (pass_rename_ssa_copies); NEXT_PASS (pass_uncprop); @@ -1487,10 +1487,20 @@ execute_one_ipa_transform_pass (struct cgraph_node *node, void execute_all_ipa_transforms (void) { + enum cgraph_state old_state = cgraph_state; struct cgraph_node *node; if (!cfun) return; node = cgraph_node (current_function_decl); + + /* Statement verification skip verification of nothorw when + state is IPA_SSA because we do not modify function bodies + after setting the flag on function. Instead we leave it + to fixup_cfg to do such a transformation. We need to temporarily + change the cgraph state so statement verifier before + transform do not fire. */ + cgraph_state = CGRAPH_STATE_IPA_SSA; + if (node->ipa_transforms_to_apply) { unsigned int i; @@ -1504,6 +1514,7 @@ execute_all_ipa_transforms (void) VEC_free (ipa_opt_pass, heap, node->ipa_transforms_to_apply); node->ipa_transforms_to_apply = NULL; } + cgraph_state = old_state; } /* Execute PASS. */ @@ -1674,8 +1685,8 @@ ipa_write_summaries_1 (cgraph_node_set set) struct lto_out_decl_state *state = lto_new_out_decl_state (); lto_push_out_decl_state (state); - if (!flag_wpa) - ipa_write_summaries_2 (all_regular_ipa_passes, set, state); + gcc_assert (!flag_wpa); + ipa_write_summaries_2 (all_regular_ipa_passes, set, state); ipa_write_summaries_2 (all_lto_gen_passes, set, state); gcc_assert (lto_get_out_decl_state () == state); @@ -1695,7 +1706,6 @@ ipa_write_summaries (void) if (!flag_generate_lto || errorcount || sorrycount) return; - lto_new_extern_inline_states (); set = cgraph_node_set_new (); /* Create the callgraph set in the same order used in @@ -1726,21 +1736,63 @@ ipa_write_summaries (void) } ipa_write_summaries_1 (set); - lto_delete_extern_inline_states (); free (order); ggc_free (set); } +/* Same as execute_pass_list but assume that subpasses of IPA passes + are local passes. If SET is not NULL, write out optimization summaries of + only those node in SET. */ + +static void +ipa_write_optimization_summaries_1 (struct opt_pass *pass, cgraph_node_set set, + struct lto_out_decl_state *state) +{ + while (pass) + { + struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass; + gcc_assert (!current_function_decl); + gcc_assert (!cfun); + gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS); + if (pass->type == IPA_PASS + && ipa_pass->write_optimization_summary + && (!pass->gate || pass->gate ())) + { + /* If a timevar is present, start it. */ + if (pass->tv_id) + timevar_push (pass->tv_id); + + ipa_pass->write_optimization_summary (set); + + /* If a timevar is present, start it. */ + if (pass->tv_id) + timevar_pop (pass->tv_id); + } + + if (pass->sub && pass->sub->type != GIMPLE_PASS) + ipa_write_optimization_summaries_1 (pass->sub, set, state); -/* Write all the summaries for the cgraph nodes in SET. If SET is + pass = pass->next; + } +} + +/* Write all the optimization summaries for the cgraph nodes in SET. If SET is NULL, write out all summaries of all nodes. */ void -ipa_write_summaries_of_cgraph_node_set (cgraph_node_set set) +ipa_write_optimization_summaries (cgraph_node_set set) { - if (flag_generate_lto && !(errorcount || sorrycount)) - ipa_write_summaries_1 (set); + struct lto_out_decl_state *state = lto_new_out_decl_state (); + lto_push_out_decl_state (state); + + gcc_assert (flag_wpa); + ipa_write_optimization_summaries_1 (all_regular_ipa_passes, set, state); + ipa_write_optimization_summaries_1 (all_lto_gen_passes, set, state); + + gcc_assert (lto_get_out_decl_state () == state); + lto_pop_out_decl_state (); + lto_delete_out_decl_state (state); } /* Same as execute_pass_list but assume that subpasses of IPA passes @@ -1785,13 +1837,57 @@ ipa_read_summaries_1 (struct opt_pass *pass) void ipa_read_summaries (void) { - if (!flag_ltrans) - ipa_read_summaries_1 (all_regular_ipa_passes); + ipa_read_summaries_1 (all_regular_ipa_passes); ipa_read_summaries_1 (all_lto_gen_passes); } /* Same as execute_pass_list but assume that subpasses of IPA passes are local passes. */ + +static void +ipa_read_optimization_summaries_1 (struct opt_pass *pass) +{ + while (pass) + { + struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass; + + gcc_assert (!current_function_decl); + gcc_assert (!cfun); + gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS); + + if (pass->gate == NULL || pass->gate ()) + { + if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary) + { + /* If a timevar is present, start it. */ + if (pass->tv_id) + timevar_push (pass->tv_id); + + ipa_pass->read_optimization_summary (); + + /* Stop timevar. */ + if (pass->tv_id) + timevar_pop (pass->tv_id); + } + + if (pass->sub && pass->sub->type != GIMPLE_PASS) + ipa_read_optimization_summaries_1 (pass->sub); + } + pass = pass->next; + } +} + +/* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */ + +void +ipa_read_optimization_summaries (void) +{ + ipa_read_optimization_summaries_1 (all_regular_ipa_passes); + ipa_read_optimization_summaries_1 (all_lto_gen_passes); +} + +/* Same as execute_pass_list but assume that subpasses of IPA passes + are local passes. */ void execute_ipa_pass_list (struct opt_pass *pass) { diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog index 143944e6d50..058c7461290 100644 --- a/gcc/po/ChangeLog +++ b/gcc/po/ChangeLog @@ -1,3 +1,11 @@ +2010-04-20 Joseph Myers + + * es.po: Update. + +2010-04-19 Joseph Myers + + * zh_CN.po: Update. + 2010-04-16 Joseph Myers * be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, id.po, ja.po, diff --git a/gcc/po/es.po b/gcc/po/es.po index 3ea755a7810..38ff5f4795a 100644 --- a/gcc/po/es.po +++ b/gcc/po/es.po @@ -1,4 +1,4 @@ -# Mensajes en español para gcc-4.5-b20100204 +# Mensajes en español para gcc-4.5.0 # Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. # This file is distributed under the same license as the gcc package. # Cristian Othón Martínez Vera , 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 @@ -7,15 +7,16 @@ # msgid "" msgstr "" -"Project-Id-Version: gcc 4.5-b20100204\n" +"Project-Id-Version: gcc 4.5.0\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" "POT-Creation-Date: 2010-04-06 14:11+0000\n" -"PO-Revision-Date: 2010-02-05 15:29-0600\n" +"PO-Revision-Date: 2010-04-16 11:29-0500\n" "Last-Translator: Cristian Othón Martínez Vera \n" "Language-Team: Spanish \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=ISO-8859-1\n" "Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" #: c-decl.c:4573 c-pretty-print.c:403 c-typeck.c:5590 toplev.c:1652 #: cp/error.c:581 cp/error.c:854 @@ -640,25 +641,25 @@ msgid "collect2 version %s" msgstr "collect2 versión %s" #: collect2.c:1823 -#, fuzzy, c-format +#, c-format msgid "%d constructor found\n" msgid_plural "%d constructors found\n" -msgstr[0] "se encuentra(n) %d constructor(es)\n" -msgstr[1] "se encuentra(n) %d constructor(es)\n" +msgstr[0] "se encontró %d constructor\n" +msgstr[1] "se encontraron %d constructores\n" #: collect2.c:1827 -#, fuzzy, c-format +#, c-format msgid "%d destructor found\n" msgid_plural "%d destructors found\n" -msgstr[0] "se encuentra(n) %d destructor(es)\n" -msgstr[1] "se encuentra(n) %d destructor(es)\n" +msgstr[0] "se encontró %d destructor\n" +msgstr[1] "se encontraron %d destructores\n" #: collect2.c:1831 -#, fuzzy, c-format +#, c-format msgid "%d frame table found\n" msgid_plural "%d frame tables found\n" -msgstr[0] "se encuentra(n) %d marcos de tabla(s)\n" -msgstr[1] "se encuentra(n) %d marcos de tabla(s)\n" +msgstr[0] "se encontró %d tabla de marco\n" +msgstr[1] "se encontraron %d tablas de marco\n" #: collect2.c:1985 lto-wrapper.c:175 #, c-format @@ -2520,9 +2521,8 @@ msgid "The maximum number of insns of a peeled loop that rolls only once" msgstr "El número máximo de insns en un ciclo pelado que se enrolla solamente una vez" #: params.def:272 -#, fuzzy msgid "The maximum depth of a loop nest we completely peel" -msgstr "El número máximo de insns en un ciclo completamente pelado" +msgstr "La profundidad máxima de un ciclo anidado que nosotros pelamos completamente" #: params.def:278 msgid "The maximum number of insns of an unswitched loop" @@ -2819,13 +2819,12 @@ msgid "size of tiles for loop blocking" msgstr "Tamaño de bloques para el bloqueo de ciclo" #: params.def:752 -#, fuzzy msgid "maximum number of parameters in a SCoP" -msgstr "el valor máximo del parámetro %qs es %u" +msgstr "número máximo de parámetros en un SCoP" #: params.def:759 msgid "maximum number of basic blocks per function to be analyzed by Graphite" -msgstr "" +msgstr "número máximo de bloques básicos por función para analizar con Graphite" #: params.def:766 msgid "Max basic blocks number in loop for loop invariant motion" @@ -2845,7 +2844,7 @@ msgstr "Tasa m #: params.def:790 msgid "Max. size of var tracking hash tables" -msgstr "" +msgstr "Tamaño máximo de las tablas de dispersión de rastreo de variables" #: params.def:797 msgid "The minimum UID to be used for a nondebug insn" @@ -4072,14 +4071,14 @@ msgid "%s:%d: instantiated from here" msgstr "%s:%d: instanciado desde aquí" #: cp/error.c:2794 -#, fuzzy, c-format +#, c-format msgid "%s:%d:%d: [ skipping %d instantiation contexts ]\n" -msgstr "%s:%d:%d: instanciado desde %qs\n" +msgstr "%s:%d:%d: [ se saltan %d contextos de instanciación ]\n" #: cp/error.c:2798 #, c-format msgid "%s:%d: [ skipping %d instantiation contexts ]\n" -msgstr "" +msgstr "%s:%d: [ se saltan %d contextos de instanciación ]\n" #: cp/g++spec.c:261 java/jvspec.c:403 #, c-format @@ -5329,9 +5328,8 @@ msgid "Allow arbitrary character line width in fixed mode" msgstr "Permite ancho de línea de carácter arbitrario en formato fijo" #: fortran/lang.opt:249 -#, fuzzy msgid "-ffixed-line-length-\tUse n as character line width in fixed mode" -msgstr "-ffixed-line-length-\t\tUsa n como ancho de línea de carácter en modo fijo" +msgstr "-ffixed-line-length-\tUsa n como ancho de línea de carácter en modo fijo" #: fortran/lang.opt:253 msgid "-ffpe-trap=[...]\tStop on following floating point exceptions" @@ -5346,9 +5344,8 @@ msgid "Allow arbitrary character line width in free mode" msgstr "Permite ancho de línea de carácter arbitrario en formato libre" #: fortran/lang.opt:265 -#, fuzzy msgid "-ffree-line-length-\tUse n as character line width in free mode" -msgstr "-ffree-line-length-\t\tUsa n como ancho de línea de carácter en modo libre" +msgstr "-ffree-line-length-\tUsa n como ancho de línea de carácter en modo libre" #: fortran/lang.opt:269 msgid "Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements" @@ -5403,9 +5400,8 @@ msgid "Try to lay out derived types as compactly as possible" msgstr "Trata de acomodar los tipos derivados tan compactos como sea posible" #: fortran/lang.opt:329 -#, fuzzy msgid "Protect parentheses in expressions" -msgstr "se sugieren paréntesis alrededor de la expresión %<>>%>" +msgstr "Protege paréntesis en las expresiones" #: fortran/lang.opt:333 msgid "Enable range checking during compilation" @@ -8958,9 +8954,8 @@ msgid "Warn for implicit type conversions that may change a value" msgstr "Avisa cuando hay conversiones de tipo implícitas que pueden cambiar un valor" #: c.opt:176 -#, fuzzy msgid "Warn for converting NULL from/to a non-pointer type" -msgstr "se convierte NULL a un tipo que no es puntero" +msgstr "Avisa cuando se convierte NULL de/a un tipo que no es puntero" #: c.opt:180 msgid "Warn for implicit type conversions between signed and unsigned integers" @@ -9503,9 +9498,8 @@ msgid "-ftabstop=\tDistance between tab stops for column reporting" msgstr "-ftabstop=\tDistancia entre topes de tabulador para reportes en columnas" #: c.opt:798 -#, fuzzy msgid "-ftemplate-depth=\tSpecify maximum template instantiation depth" -msgstr "-ftemplate-depth-\tEspecifica la profundidad máxima de instanciación de plantillas" +msgstr "-ftemplate-depth-\tEspecifica la profundidad máxima de instanciación de plantilla" #: c.opt:805 msgid "-fno-threadsafe-statics\tDo not generate thread-safe code for initializing local statics" @@ -9912,9 +9906,8 @@ msgid "-dumpbase \tSet the file basename to be used for dumps" msgstr "-dumpbase \tEstablece el nombre base de fichero a usar para los volcados" #: common.opt:258 -#, fuzzy msgid "-dumpdir \tSet the directory name to be used for dumps" -msgstr "-dumpdir \t\tEstablece el nombre del directorio a usar para los volcados" +msgstr "-dumpdir \tEstablece el nombre del directorio a usar para los volcados" #: common.opt:284 msgid "Align the start of functions" @@ -12487,9 +12480,9 @@ msgid "%qE undeclared (first use in this function)" msgstr "%qE no se declaró aquí (primer uso en esta función)" #: c-decl.c:2954 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "each undeclared identifier is reported only once for each function it appears in" -msgstr "(Cada identificador sin declarar es reportado sólo una vez para cada función en el que aparece.)" +msgstr "cada identificador sin declarar se reporta sólo una vez para cada función en el que aparece" #: c-decl.c:3004 cp/decl.c:2446 #, gcc-internal-format @@ -15190,9 +15183,9 @@ msgid "function with qualified void return type called" msgstr "se llamó a una función con tipo de devolución void calificado" #: c-typeck.c:2820 c-typeck.c:3047 cp/typeck.c:3315 cp/typeck.c:3429 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declared here" -msgstr "%qD se declara aquí" +msgstr "se declara aquí" #: c-typeck.c:2855 #, gcc-internal-format @@ -16760,7 +16753,7 @@ msgstr "DW_LOC_OP %s no est #: dwarf2out.c:12859 #, gcc-internal-format msgid "non-delegitimized UNSPEC %d found in variable location" -msgstr "" +msgstr "se encontró UNSPEC %d que no está delegitimado la ubicación de variable" #: emit-rtl.c:2460 #, gcc-internal-format @@ -19334,12 +19327,12 @@ msgstr "Valor de perfil corrupto: %s la cuenta general del perfilador (%d) no co #: var-tracking.c:6051 #, gcc-internal-format msgid "variable tracking size limit exceeded with -fvar-tracking-assignments, retrying without" -msgstr "" +msgstr "se excedió el límite de tamaño de rastreo de variable con -fvar-track-assignments, reintente sin esa opción" #: var-tracking.c:6055 #, gcc-internal-format msgid "variable tracking size limit exceeded" -msgstr "" +msgstr "se excedió el límite de tamaño de rastreo de variable" #: varasm.c:580 #, gcc-internal-format @@ -19705,9 +19698,9 @@ msgid "bad value %qs for -mcpu switch" msgstr "valor %qs erróneo para el interruptor -mcpu" #: config/alpha/alpha.c:391 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "bad value %qs for -mtune switch" -msgstr "valor erróneo (%s) para la opción -mtune=" +msgstr "valor erróneo %qs para la opción -mtune" #: config/alpha/alpha.c:398 #, gcc-internal-format @@ -23387,24 +23380,24 @@ msgid "cannot convert %qE from type %qT to type %qT" msgstr "no se puede convertir %qE desde el tipo %qT al tipo %qT" #: cp/cvt.c:371 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "initialization of volatile reference type %q#T from rvalue of type %qT" -msgstr "inicialización inválida de una referencia que no es constante de tipo %qT desde un r-valor de tipo %qT" +msgstr "inicialización de un tipo de referencia volatile %q#T desde un r-valor de tipo %qT" #: cp/cvt.c:374 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conversion to volatile reference type %q#T from rvalue of type %qT" -msgstr "inicialización inválida de una referencia que no es constante de tipo %qT desde un r-valor de tipo %qT" +msgstr "inicialización a un tipo de referencia volatile %q#T desde un r-valor de tipo %qT" #: cp/cvt.c:377 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "initialization of non-const reference type %q#T from rvalue of type %qT" -msgstr "inicialización inválida de una referencia que no es constante de tipo %qT desde un r-valor de tipo %qT" +msgstr "inicialización de un tipo de referencia que no es constante %q#T desde un r-valor de tipo %qT" #: cp/cvt.c:380 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conversion to non-const reference type %q#T from rvalue of type %qT" -msgstr "inicialización inválida de una referencia que no es constante de tipo %qT desde un r-valor de tipo %qT" +msgstr "inicialización a un tipo de referencia que no es constante %q#T desde un r-valor de tipo %qT" #: cp/cvt.c:453 #, gcc-internal-format @@ -25565,9 +25558,9 @@ msgid "%qD is already defined in %qT" msgstr "%qD ya está definido en %qT" #: cp/decl2.c:917 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid initializer for member function %qD" -msgstr "valor inicial inválido para el miembro %qE" +msgstr "inicializador inválido para la función miembro %qD" #: cp/decl2.c:923 #, gcc-internal-format @@ -25698,7 +25691,7 @@ msgstr "falta el argumento por defecto para el par #: cp/decl2.c:4017 #, gcc-internal-format msgid "converting lambda which uses %<...%> to function pointer" -msgstr "" +msgstr "se convierte lambda la cual usa %<...%> a un puntero de función" #: cp/decl2.c:4022 cp/search.c:1892 #, gcc-internal-format @@ -26209,7 +26202,7 @@ msgstr "el nombre revuelto de %qD cambiar #: cp/mangle.c:3071 #, gcc-internal-format msgid "-fabi-version=4 (or =0) avoids this error with a change in vector mangling" -msgstr "" +msgstr "-fabi-version=4 (o =0) evita este error con un cambio en el manejo de vectores" #: cp/method.c:396 #, gcc-internal-format @@ -26267,9 +26260,9 @@ msgid "function %q+D defaulted on its first declaration must not have an excepti msgstr "la función %q+D definida por defecto en su primera declaración no puede tener una especificación-de-excepción" #: cp/method.c:1081 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD declared virtual cannot be defaulted in the class body" -msgstr "%qD declarada explícitamente no se puede definir por defecto en el cuerpo de clase" +msgstr "%qD declarada virtual no se puede definir por defecto en el cuerpo de clase" #: cp/method.c:1130 #, gcc-internal-format @@ -26712,14 +26705,14 @@ msgid "typedef-name %qD used as destructor declarator" msgstr "se usa el nombre-de-definición-de-tipo %qD como un declarador de destructor" #: cp/parser.c:4552 cp/parser.c:6165 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in casts" -msgstr "no se pueden definir tipos nuevos en un tipo de devolución" +msgstr "los tipos no se pueden definir en conversiones" #: cp/parser.c:4615 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in a % expression" -msgstr "no se pueden definir tipos nuevos en un tipo de devolución" +msgstr "no se pueden definir tipos en una expresión %" #. Warn the user that a compound literal is not #. allowed in standard C++. @@ -26749,9 +26742,9 @@ msgid "try removing the parentheses around the type-id" msgstr "intente borrar los paréntesis alrededor del id-de-tipo" #: cp/parser.c:5852 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in a new-type-id" -msgstr "no se pueden definir tipos nuevos en un tipo de devolución" +msgstr "no se pueden definir tipos en un id-tipo-nuevo" #: cp/parser.c:5976 #, gcc-internal-format @@ -26804,9 +26797,9 @@ msgid "%<%T::%D%> names the constructor, not the type" msgstr "%<%T::%D%> nombra el constructor, no el tipo" #: cp/parser.c:8113 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in conditions" -msgstr "no se pueden definir tipos nuevos en un tipo de devolución" +msgstr "no se pueden definir tipos en condiciones" #. Issue a warning about this use of a GNU extension. #: cp/parser.c:8462 @@ -26852,9 +26845,9 @@ msgid "templates may not be %" msgstr "las plantillas no pueden ser %" #: cp/parser.c:9523 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in % expressions" -msgstr "no se pueden definir tipos nuevos en un tipo de devolución" +msgstr "no se pueden definir tipos en expresiones %" #: cp/parser.c:9778 #, gcc-internal-format @@ -27029,9 +27022,9 @@ msgid "invalid use of %" msgstr "uso inválido de %" #: cp/parser.c:15039 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in parameter types" -msgstr "no se pueden definir tipos nuevos en un tipo de devolución" +msgstr "no se pueden definir tipos en tipos de parámetro" #: cp/parser.c:15257 #, gcc-internal-format @@ -27114,14 +27107,14 @@ msgid "keyword % not allowed in this context (the base class is impli msgstr "no se permite la palabra clave % en este contexto (la clase base es implícitamente un tipo)" #: cp/parser.c:17229 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in an exception-specification" -msgstr "no se pueden definir tipos nuevos en un tipo de devolución" +msgstr "no se pueden definir tipos en una especificación de excepción" #: cp/parser.c:17410 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in exception-declarations" -msgstr "no se pueden definir tipos nuevos en un tipo de devolución" +msgstr "no se pueden definir tipos en declaraciones de excepción" #: cp/parser.c:18303 #, gcc-internal-format @@ -27480,11 +27473,11 @@ msgid "template argument %qE involves template parameter(s)" msgstr "el argumento de plantilla %qE involucra a el(los) parámetro(s) de plantilla" #: cp/pt.c:4022 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type %qT of template argument %qE depends on a template parameter" msgid_plural "type %qT of template argument %qE depends on template parameters" -msgstr[0] "el tipo %qT del argumento de plantilla %qE depende de el(los) parámetro(s) de plantilla" -msgstr[1] "el tipo %qT del argumento de plantilla %qE depende de el(los) parámetro(s) de plantilla" +msgstr[0] "el tipo %qT del argumento de plantilla %qE depende de un parámetro de plantilla" +msgstr[1] "el tipo %qT del argumento de plantilla %qE depende de parámetros de plantilla" #: cp/pt.c:4129 #, gcc-internal-format @@ -27502,29 +27495,29 @@ msgid "parameter pack %qT must be at the end of the template parameter list" msgstr "el parámetro de paquete %qT debe estar al final de la lista de parámetros de plantilla" #: cp/pt.c:4190 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default template arguments may not be used in function template friend re-declaration" -msgstr "no se permiten los argumentos por defecto en la declaración de la especialización friend de la plantilla %qD" +msgstr "no se pueden usar los argumentos de plantilla por defecto en la re-declaración friend de la plantilla de función" #: cp/pt.c:4193 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default template arguments may not be used in function template friend declarations" -msgstr "no se permiten los argumentos por defecto en la declaración de la especialización friend de la plantilla %qD" +msgstr "no se pueden usar los argumentos de plantilla por defecto en las declaraciones friend de la plantilla de función" #: cp/pt.c:4196 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default template arguments may not be used in function templates without -std=c++0x or -std=gnu++0x" -msgstr "las funciones por defecto y borradas sólo están disponibles con -std=c++0x o -std=gnu++0x" +msgstr "los argumentos de plantilla por defecto no se pueden usar en las plantillas de función sin -std=c++0x o -std=gnu++0x" #: cp/pt.c:4199 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default template arguments may not be used in partial specializations" -msgstr "no se usan los parámetros de plantilla en la especialización parcial:" +msgstr "no se pueden usar los argumentos de plantilla por defecto en las especializaciones parciales" #: cp/pt.c:4202 cp/pt.c:4253 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default argument for template parameter for class enclosing %qD" -msgstr "el argumento por defecto para el parámetro del tipo %qT tiene el tipo %qT" +msgstr "argumento por defecto para el parámetro de plantilla para la clase incluyente %qD" #: cp/pt.c:4346 #, gcc-internal-format @@ -27595,18 +27588,18 @@ msgid "template specifiers not specified in declaration of %qD" msgstr "no se especificaron los especificadores de plantilla en la declaración de %qD" #: cp/pt.c:4693 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "redeclared with %d template parameter" msgid_plural "redeclared with %d template parameters" -msgstr[0] "se redeclaró con %d parámetro(s) de plantilla" -msgstr[1] "se redeclaró con %d parámetro(s) de plantilla" +msgstr[0] "se redeclaró con %d parámetro de plantilla" +msgstr[1] "se redeclaró con %d parámetros de plantilla" #: cp/pt.c:4697 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previous declaration %q+D used %d template parameter" msgid_plural "previous declaration %q+D used %d template parameters" -msgstr[0] "la declaración previa de %q+#D usó %d parámetro(s) de plantilla" -msgstr[1] "la declaración previa de %q+#D usó %d parámetro(s) de plantilla" +msgstr[0] "la declaración previa de %q+#D usó %d parámetro de plantilla" +msgstr[1] "la declaración previa de %q+#D usó %d parámetros de plantilla" #: cp/pt.c:4734 #, gcc-internal-format @@ -27820,9 +27813,9 @@ msgid "for template declaration %q+D" msgstr "para la declaración de plantilla %q+D" #: cp/pt.c:7060 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum) instantiating %qD" -msgstr "la profundidad de instanciación de la plantilla excede el máximo de %d (use -ftemplate-depth-NN para incrementar el máximo) al instanciar %qD" +msgstr "la profundidad de instanciación de la plantilla excede el máximo de %d (use -ftemplate-depth= para incrementar el máximo) al instanciar %qD" #: cp/pt.c:8326 #, gcc-internal-format @@ -28105,9 +28098,9 @@ msgid "explicit instantiation of %qD but no definition available" msgstr "instanciación explícita de %qD pero no hay una definición disponible" #: cp/pt.c:16910 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth= to increase the maximum)" -msgstr "la profundidad de instanciación de la plantilla excede el máximo de %d al instanciar %q+D, posiblemente de la generación de tabla virtual (use -ftemplate-depth-NN para incrementar el máximo)" +msgstr "la profundidad de instanciación de la plantilla excede el máximo de %d al instanciar %q+D, posiblemente de la generación de tabla virtual (use -ftemplate-depth= para incrementar el máximo)" #: cp/pt.c:17265 #, gcc-internal-format @@ -28120,9 +28113,9 @@ msgid "deducing from brace-enclosed initializer list requires #include " #: cp/pt.c:18315 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "variable %q#D with % type used in its own initializer" -msgstr "la variable %D de tipo % no debe ser inicializada" +msgstr "se usó la variable %q#D con tipo % en su propio inicializador" #: cp/pt.c:18337 #, gcc-internal-format @@ -28834,9 +28827,9 @@ msgid "%qE cannot be used as a function" msgstr "no se puede usar %qE como una función" #: cp/typeck.c:3312 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "too many arguments to %s %q#D" -msgstr "demasiados argumentos para %s %q+#D" +msgstr "demasiados argumentos para %s %q#D" #: cp/typeck.c:3318 #, gcc-internal-format @@ -28854,9 +28847,9 @@ msgid "parameter %P has incomplete type %qT" msgstr "el parámetro %P tiene el tipo incompleto %qT" #: cp/typeck.c:3426 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "too few arguments to %s %q#D" -msgstr "faltan argumentos para %s %q+#D" +msgstr "faltan argumentos para %s %q#D" #: cp/typeck.c:3432 #, gcc-internal-format @@ -34537,9 +34530,9 @@ msgid "The element in the derived type constructor at %L, for pointer component msgstr "El elemento en el constructor de tipo derivado en %L, para el componente puntero '%s', debe ser un POINTER o un TARGET" #: fortran/resolve.c:930 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "Invalid expression in the derived type constructor for pointer component '%s' at %L in PURE procedure" -msgstr "El elemento en el constructor de tipo derivado en %L, para el componente puntero '%s', es %s pero debería ser %s" +msgstr "Expresión inválida en el constructor de tipo derivado para el componente puntero '%s' en %L en el procedimiento PURE" #: fortran/resolve.c:1052 #, gcc-internal-format @@ -35427,7 +35420,7 @@ msgstr "La etiqueta enlazante '%s' en %L colisiona con la entidad global '%s' en #: fortran/resolve.c:8587 #, gcc-internal-format msgid "CHARACTER variable at %L has negative length %d, the length has been set to zero" -msgstr "" +msgstr "La variable CHARACTER en %L tiene longitud negativa %d, la longitud se estableció a cero" #: fortran/resolve.c:8599 #, gcc-internal-format @@ -35462,7 +35455,7 @@ msgstr "El tipo '%s' no se puede asociar al anfitri #: fortran/resolve.c:8964 #, gcc-internal-format msgid "Fortran 2008: Implied SAVE for module variable '%s' at %L, needed due to the default initialization" -msgstr "" +msgstr "Fortran 2008: SAVE implícito para la variable de módulo '%s' en %L, se necesita por la inicialización por defecto" #: fortran/resolve.c:8975 #, gcc-internal-format diff --git a/gcc/po/zh_CN.po b/gcc/po/zh_CN.po index af1096aedaa..0b797938c44 100644 --- a/gcc/po/zh_CN.po +++ b/gcc/po/zh_CN.po @@ -5,10 +5,10 @@ # msgid "" msgstr "" -"Project-Id-Version: gcc 4.5-b20100204\n" +"Project-Id-Version: gcc 4.5.0\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" "POT-Creation-Date: 2010-04-06 14:11+0000\n" -"PO-Revision-Date: 2010-03-09 14:42+0800\n" +"PO-Revision-Date: 2010-04-19 14:57+0800\n" "Last-Translator: Meng Jie \n" "Language-Team: Chinese (simplified) \n" "MIME-Version: 1.0\n" @@ -16,7 +16,8 @@ msgstr "" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-Language: Chinese\n" "X-Poedit-Country: CHINA\n" -"X-Poedit-Basepath: C:\\MSYS\\source\\gcc-4.5-20091203\\gcc\n" +"X-Poedit-Basepath: C:\\MSYS\\source\\gcc-4.5.0\\gcc\n" +"Plural-Forms: nplurals=1; plural=0;\n" #: c-decl.c:4573 c-pretty-print.c:403 c-typeck.c:5590 toplev.c:1652 #: cp/error.c:581 cp/error.c:854 @@ -641,25 +642,22 @@ msgid "collect2 version %s" msgstr "collect2 版本 %s" #: collect2.c:1823 -#, fuzzy, c-format +#, c-format msgid "%d constructor found\n" msgid_plural "%d constructors found\n" msgstr[0] "找到 %d 个构造函数\n" -msgstr[1] "找到 %d 个构造函数\n" #: collect2.c:1827 -#, fuzzy, c-format +#, c-format msgid "%d destructor found\n" msgid_plural "%d destructors found\n" msgstr[0] "找到 %d 个析构函数\n" -msgstr[1] "找到 %d 个析构函数\n" #: collect2.c:1831 -#, fuzzy, c-format +#, c-format msgid "%d frame table found\n" msgid_plural "%d frame tables found\n" -msgstr[0] "找到了 %d 个框架表\n" -msgstr[1] "找到了 %d 个框架表\n" +msgstr[0] "找到 %d 个框架表\n" #: collect2.c:1985 lto-wrapper.c:175 #, c-format @@ -2508,9 +2506,8 @@ msgid "The maximum number of insns of a peeled loop that rolls only once" msgstr "被剥离后只卷绕一次的循环包含的最多指令数" #: params.def:272 -#, fuzzy msgid "The maximum depth of a loop nest we completely peel" -msgstr "一个完全剥离的循环所能有的最大指令数" +msgstr "一个完全剥离的循环嵌套所能有的最大深度" #: params.def:278 msgid "The maximum number of insns of an unswitched loop" @@ -2805,13 +2802,12 @@ msgid "size of tiles for loop blocking" msgstr "循环分块中每小块的大小" #: params.def:752 -#, fuzzy msgid "maximum number of parameters in a SCoP" -msgstr "参数%qs的最大值是 %u" +msgstr "一个静态控制部分(ScoP)中参数的最大数量" #: params.def:759 msgid "maximum number of basic blocks per function to be analyzed by Graphite" -msgstr "" +msgstr "Graphite 可分析的每函数所包含的基本块数量上限" #: params.def:766 msgid "Max basic blocks number in loop for loop invariant motion" @@ -2831,7 +2827,7 @@ msgstr "为循环启用预取时最小的指令/内存操作比" #: params.def:790 msgid "Max. size of var tracking hash tables" -msgstr "" +msgstr "变量跟踪散列表的最大尺寸" #: params.def:797 msgid "The minimum UID to be used for a nondebug insn" @@ -4058,14 +4054,14 @@ msgid "%s:%d: instantiated from here" msgstr "%s:%d：从此处实例化" #: cp/error.c:2794 -#, fuzzy, c-format +#, c-format msgid "%s:%d:%d: [ skipping %d instantiation contexts ]\n" -msgstr "%s:%d:%d：自%qs实例化\n" +msgstr "%s:%d:%d：[ 跳过 %d 个实例化上下文 ]\n" #: cp/error.c:2798 #, c-format msgid "%s:%d: [ skipping %d instantiation contexts ]\n" -msgstr "" +msgstr "%s:%d：[ 跳过 %d 个实例化上下文 ]\n" #: cp/g++spec.c:261 java/jvspec.c:403 #, c-format @@ -5314,9 +5310,8 @@ msgid "Allow arbitrary character line width in fixed mode" msgstr "在固定模式下允许任意的字符行宽" #: fortran/lang.opt:249 -#, fuzzy msgid "-ffixed-line-length-\tUse n as character line width in fixed mode" -msgstr "-ffixed-line-length-\t\t在固定模式下以 n 作为字符行宽" +msgstr "-ffixed-line-length-\t在固定模式下以 n 作为字符行宽" #: fortran/lang.opt:253 msgid "-ffpe-trap=[...]\tStop on following floating point exceptions" @@ -5331,9 +5326,8 @@ msgid "Allow arbitrary character line width in free mode" msgstr "在自由模式下允许任意的字符行宽" #: fortran/lang.opt:265 -#, fuzzy msgid "-ffree-line-length-\tUse n as character line width in free mode" -msgstr "-ffree-line-length-\t\t在自由模式下以 n 作为字符行宽" +msgstr "-ffree-line-length-\t在自由模式下以 n 作为字符行宽" #: fortran/lang.opt:269 msgid "Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements" @@ -5388,9 +5382,8 @@ msgid "Try to lay out derived types as compactly as possible" msgstr "为派生类型使用尽可能紧实的布局" #: fortran/lang.opt:329 -#, fuzzy msgid "Protect parentheses in expressions" -msgstr "建议%<>>%>表达式周围加上括号" +msgstr "尊重表达式中的括号" #: fortran/lang.opt:333 msgid "Enable range checking during compilation" @@ -8935,9 +8928,8 @@ msgid "Warn for implicit type conversions that may change a value" msgstr "当隐式类型转换可能改变值时给出警告" #: c.opt:176 -#, fuzzy msgid "Warn for converting NULL from/to a non-pointer type" -msgstr "将 NULL 转换为非指针类型" +msgstr "将 NULL 转换为非指针类型时给出警告" #: c.opt:180 msgid "Warn for implicit type conversions between signed and unsigned integers" @@ -9480,9 +9472,8 @@ msgid "-ftabstop=\tDistance between tab stops for column reporting" msgstr "-ftabstop=\t指定报告列号时制表位间的距离" #: c.opt:798 -#, fuzzy msgid "-ftemplate-depth=\tSpecify maximum template instantiation depth" -msgstr "-ftemplate-depth-\t指定模板实例化的最大深度" +msgstr "-ftemplate-depth=\t指定模板实例化的最大深度" #: c.opt:805 msgid "-fno-threadsafe-statics\tDo not generate thread-safe code for initializing local statics" @@ -9889,9 +9880,8 @@ msgid "-dumpbase \tSet the file basename to be used for dumps" msgstr "-dumpbase <文件>\t设定内存转储使用的文件基本名" #: common.opt:258 -#, fuzzy msgid "-dumpdir \tSet the directory name to be used for dumps" -msgstr "-dumpdir <目录>\t\t设定内存转储使用的目录名" +msgstr "-dumpdir <目录>\t设定内存转储使用的目录名" #: common.opt:284 msgid "Align the start of functions" @@ -12457,9 +12447,9 @@ msgid "%qE undeclared (first use in this function)" msgstr "%qE未声明(在此函数内第一次使用)" #: c-decl.c:2954 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "each undeclared identifier is reported only once for each function it appears in" -msgstr "(即使在一个函数内多次出现，每个未声明的标识符在其" +msgstr "每个未声明的标识符在其出现的函数内只报告一次" #: c-decl.c:3004 cp/decl.c:2446 #, gcc-internal-format @@ -15160,9 +15150,9 @@ msgid "function with qualified void return type called" msgstr "调用了有限定 void 返回类型的函数" #: c-typeck.c:2820 c-typeck.c:3047 cp/typeck.c:3315 cp/typeck.c:3429 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declared here" -msgstr "%qD在此声明" +msgstr "在此声明" #: c-typeck.c:2855 #, gcc-internal-format @@ -16730,7 +16720,7 @@ msgstr "DW_LOC_OP %s 尚未实现" #: dwarf2out.c:12859 #, gcc-internal-format msgid "non-delegitimized UNSPEC %d found in variable location" -msgstr "" +msgstr "变量位置处发现未被非法化的 UNSPEC %d" #: emit-rtl.c:2460 #, gcc-internal-format @@ -19304,12 +19294,12 @@ msgstr "损坏的值取样：%s 取样总数(%d)与基本块数(%d)不匹配" #: var-tracking.c:6051 #, gcc-internal-format msgid "variable tracking size limit exceeded with -fvar-tracking-assignments, retrying without" -msgstr "" +msgstr "变量跟踪大小越限，请不带 -fvar-tracking-assignments 重试" #: var-tracking.c:6055 #, gcc-internal-format msgid "variable tracking size limit exceeded" -msgstr "" +msgstr "变量跟踪大小越限" #: varasm.c:580 #, gcc-internal-format @@ -19675,9 +19665,9 @@ msgid "bad value %qs for -mcpu switch" msgstr "-mcpu 开关的值%qs错误" #: config/alpha/alpha.c:391 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "bad value %qs for -mtune switch" -msgstr "-mcpu 开关的值%qs错误" +msgstr "-mtune 开关的值%qs错误" #: config/alpha/alpha.c:398 #, gcc-internal-format @@ -23355,24 +23345,24 @@ msgid "cannot convert %qE from type %qT to type %qT" msgstr "无法将%qE从类型%qT转换到类型%qT" #: cp/cvt.c:371 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "initialization of volatile reference type %q#T from rvalue of type %qT" -msgstr "用类型为%2$qT的右值初始化类型为%1$qT的非常量引用无效" +msgstr "用类型为%2$qT的右值初始化类型为%1$q#T的 volatile 引用" #: cp/cvt.c:374 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conversion to volatile reference type %q#T from rvalue of type %qT" -msgstr "用类型为%2$qT的右值初始化类型为%1$qT的非常量引用无效" +msgstr "将类型为%2$qT的右值转换为%1$qT的 volatile 引用" #: cp/cvt.c:377 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "initialization of non-const reference type %q#T from rvalue of type %qT" -msgstr "用类型为%2$qT的右值初始化类型为%1$qT的非常量引用无效" +msgstr "用类型为%2$qT的右值初始化非常量引用类型%1$q#T" #: cp/cvt.c:380 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conversion to non-const reference type %q#T from rvalue of type %qT" -msgstr "用类型为%2$qT的右值初始化类型为%1$qT的非常量引用无效" +msgstr "将类型为%2$qT的右值转换为非常量引用类型%1$q#T" #: cp/cvt.c:453 #, gcc-internal-format @@ -24209,7 +24199,7 @@ msgstr "%q+D声明为友元" #: cp/decl.c:6546 #, gcc-internal-format msgid "%q+D declared with an exception specification" -msgstr "%q+D声明时有异常指定" +msgstr "%q+D声明时带有异常规范" #: cp/decl.c:6580 #, gcc-internal-format @@ -25527,9 +25517,9 @@ msgid "%qD is already defined in %qT" msgstr "%qD已在%qT中定义过" #: cp/decl2.c:917 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid initializer for member function %qD" -msgstr "成员%qE的初始值无效" +msgstr "成员函数%qD的初始值设定无效" #: cp/decl2.c:923 #, gcc-internal-format @@ -25660,7 +25650,7 @@ msgstr "%2$q+#D的第 %1$P 个形参缺少默认实参" #: cp/decl2.c:4017 #, gcc-internal-format msgid "converting lambda which uses %<...%> to function pointer" -msgstr "" +msgstr "将使用了%<...%>的 Lambda 转换为函数指针" #: cp/decl2.c:4022 cp/search.c:1892 #, gcc-internal-format @@ -26171,7 +26161,7 @@ msgstr "%qD修饰后的名字将在 GCC 的未来版本中有变化" #: cp/mangle.c:3071 #, gcc-internal-format msgid "-fabi-version=4 (or =0) avoids this error with a change in vector mangling" -msgstr "" +msgstr "-fabi-version=4 (or =0) 可以改变向量修饰来避免这个错误" #: cp/method.c:396 #, gcc-internal-format @@ -26229,9 +26219,9 @@ msgid "function %q+D defaulted on its first declaration must not have an excepti msgstr "首次声明时被默认化的函数%q+D不可以指定异常" #: cp/method.c:1081 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD declared virtual cannot be defaulted in the class body" -msgstr "声明为 explicit 的%qD不能在类体内被默认化" +msgstr "声明为 virtual 的%qD不能在类体内指定默认值" #: cp/method.c:1130 #, gcc-internal-format @@ -26674,14 +26664,14 @@ msgid "typedef-name %qD used as destructor declarator" msgstr "typedef 名%qD用于析构函数声明" #: cp/parser.c:4552 cp/parser.c:6165 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in casts" -msgstr "不能在返回类型中定义新类型" +msgstr "类型不能定义在类型转换中" #: cp/parser.c:4615 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in a % expression" -msgstr "不能在返回类型中定义新类型" +msgstr "类型不能定义在%表达式中" #. Warn the user that a compound literal is not #. allowed in standard C++. @@ -26711,9 +26701,9 @@ msgid "try removing the parentheses around the type-id" msgstr "请尝试删除类型标识符两边的括号" #: cp/parser.c:5852 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in a new-type-id" -msgstr "不能在返回类型中定义新类型" +msgstr "类型不能定义在 new-type-id 中" #: cp/parser.c:5976 #, gcc-internal-format @@ -26766,9 +26756,9 @@ msgid "%<%T::%D%> names the constructor, not the type" msgstr "%<%T::%D%>命名了一个构造函数而非类型" #: cp/parser.c:8113 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in conditions" -msgstr "不能在返回类型中定义新类型" +msgstr "类型不能定义在条件表达式中" #. Issue a warning about this use of a GNU extension. #: cp/parser.c:8462 @@ -26814,9 +26804,9 @@ msgid "templates may not be %" msgstr "模板不能是%的" #: cp/parser.c:9523 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in % expressions" -msgstr "不能在返回类型中定义新类型" +msgstr "类型不能定义在%中" #: cp/parser.c:9778 #, gcc-internal-format @@ -26991,9 +26981,9 @@ msgid "invalid use of %" msgstr "错误地使用了%" #: cp/parser.c:15039 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in parameter types" -msgstr "不能在返回类型中定义新类型" +msgstr "类型不能定义在参数类型中" #: cp/parser.c:15257 #, gcc-internal-format @@ -27076,14 +27066,14 @@ msgid "keyword % not allowed in this context (the base class is impli msgstr "关键字%不允许用在此上下文中(基类隐式地是一个类型)" #: cp/parser.c:17229 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in an exception-specification" -msgstr "不能在返回类型中定义新类型" +msgstr "类型不能定义在异常规范中" #: cp/parser.c:17410 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "types may not be defined in exception-declarations" -msgstr "不能在返回类型中定义新类型" +msgstr "类型不能定义在异常声明中" #: cp/parser.c:18303 #, gcc-internal-format @@ -27442,11 +27432,10 @@ msgid "template argument %qE involves template parameter(s)" msgstr "模板实参%qE混杂了模板形参" #: cp/pt.c:4022 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type %qT of template argument %qE depends on a template parameter" msgid_plural "type %qT of template argument %qE depends on template parameters" msgstr[0] "模板实参%2$qE的类型%1$qT取决于模板参数" -msgstr[1] "模板实参%2$qE的类型%1$qT取决于模板参数" #: cp/pt.c:4129 #, gcc-internal-format @@ -27464,29 +27453,29 @@ msgid "parameter pack %qT must be at the end of the template parameter list" msgstr "参数包%qT必须出现在模板形参表末尾" #: cp/pt.c:4190 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default template arguments may not be used in function template friend re-declaration" -msgstr "友元模板特例化%qD中不允许出现默认参数" +msgstr "默认参数不能用在函数模板友元重声明中" #: cp/pt.c:4193 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default template arguments may not be used in function template friend declarations" -msgstr "友元模板特例化%qD中不允许出现默认参数" +msgstr "默认参数不能用在函数模板友元重声明中" #: cp/pt.c:4196 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default template arguments may not be used in function templates without -std=c++0x or -std=gnu++0x" -msgstr "默认化和被删除的函数只在 -std=c++0x 或 -std=gnu++0x 下可用" +msgstr "只有指定了 -std=c++0x 或 -std=gnu++0x 时才能在函数模板中使用默认参数" #: cp/pt.c:4199 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default template arguments may not be used in partial specializations" -msgstr "部分特例化中未用到模板参数：" +msgstr "默认参数不能用在部分特例化中" #: cp/pt.c:4202 cp/pt.c:4253 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default argument for template parameter for class enclosing %qD" -msgstr "类型为%qT的形参的默认实参却有类型%qT" +msgstr "包含%qD的类的模板参数有默认参数" #: cp/pt.c:4346 #, gcc-internal-format @@ -27557,18 +27546,16 @@ msgid "template specifiers not specified in declaration of %qD" msgstr "%qD的声明中没有 template 限定" #: cp/pt.c:4693 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "redeclared with %d template parameter" msgid_plural "redeclared with %d template parameters" -msgstr[0] "重声明为具有%d个模板参数" -msgstr[1] "重声明为具有%d个模板参数" +msgstr[0] "重声明为具有 %d 个模板参数" #: cp/pt.c:4697 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previous declaration %q+D used %d template parameter" msgid_plural "previous declaration %q+D used %d template parameters" -msgstr[0] "先前的声明%q+D使用了%d个模板参数" -msgstr[1] "先前的声明%q+D使用了%d个模板参数" +msgstr[0] "先前的声明%q+D使用了 %d 个模板参数" #: cp/pt.c:4734 #, gcc-internal-format @@ -27782,9 +27769,9 @@ msgid "for template declaration %q+D" msgstr "对于模板声明%q+D" #: cp/pt.c:7060 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum) instantiating %qD" -msgstr "模板实例化深度超过最大值 %d(使用 use -ftemplate-depth-NN 来增大最大值)，在实例化%qD时" +msgstr "在实例化%2$qD时模板实例化深度超过最大值 %1$d(使用 use -ftemplate-depth= 来增大最大值)" #: cp/pt.c:8326 #, gcc-internal-format @@ -28067,9 +28054,9 @@ msgid "explicit instantiation of %qD but no definition available" msgstr "显式实例化%qD时没有可用的定义" #: cp/pt.c:16910 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth= to increase the maximum)" -msgstr "模板实例化深度超过了最大值 %d，当实例化%q+D时，可能是由于生成虚函数表所致(使用 -ftemplate-depth-NN 来增大最大值)" +msgstr "在实例化%2$q+D时模板实例化深度超过了最大值 %1$d，可能是由于生成虚函数表所致(使用 -ftemplate-depth= 来增大最大值)" #: cp/pt.c:17265 #, gcc-internal-format @@ -28082,9 +28069,9 @@ msgid "deducing from brace-enclosed initializer list requires #include " #: cp/pt.c:18315 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "variable %q#D with % type used in its own initializer" -msgstr "类型为%的变量 %D 不能被初始化" +msgstr "变量‘%q#D’在其自身的初始值设定中使用了%类型" #: cp/pt.c:18337 #, gcc-internal-format @@ -28796,9 +28783,9 @@ msgid "%qE cannot be used as a function" msgstr "%qE不能用作函数" #: cp/typeck.c:3312 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "too many arguments to %s %q#D" -msgstr "给予 %s%q+#D的实参太多" +msgstr "给予 %s%q+#D的参数太多" #: cp/typeck.c:3318 #, gcc-internal-format @@ -28816,9 +28803,9 @@ msgid "parameter %P has incomplete type %qT" msgstr "形参 %P 的类型%qT不完全" #: cp/typeck.c:3426 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "too few arguments to %s %q#D" -msgstr "给予 %s%q+#D的实参太少" +msgstr "给予 %s%q+#D的参数太少" #: cp/typeck.c:3432 #, gcc-internal-format @@ -34490,9 +34477,9 @@ msgid "The element in the derived type constructor at %L, for pointer component msgstr "%L处指针组件‘%s’的派生类型构造函数中的元素应该是 POINTER 或 TARGET" #: fortran/resolve.c:930 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "Invalid expression in the derived type constructor for pointer component '%s' at %L in PURE procedure" -msgstr "%L处指针组件‘%s’的派生类型构造函数中的元素是 %s 但应该是 %s" +msgstr "%2$L处指针组件‘%1$s’的派生类型构造函数中表达式无效" #: fortran/resolve.c:1052 #, gcc-internal-format @@ -35370,7 +35357,7 @@ msgstr "%2$L处的绑定标号‘%1$s’与 %4$L 处的全局实体‘%3$s’冲 #: fortran/resolve.c:8496 #, gcc-internal-format msgid "Binding label '%s' in interface body at %L collides with the global entity '%s' at %L" -msgstr "%2$L处的接口体‘%1$s’中的绑定标记‘%1$s’与%4$L处的全局实体‘%3$s’冲突" +msgstr "%2$L处的接口体中的绑定标记‘%1$s’与%4$L处的全局实体‘%3$s’冲突" #: fortran/resolve.c:8509 #, gcc-internal-format @@ -35380,7 +35367,7 @@ msgstr "%2$L处的捆绑标号‘%1$s’与 %4$L 处的全局实体‘%3$s’冲 #: fortran/resolve.c:8587 #, gcc-internal-format msgid "CHARACTER variable at %L has negative length %d, the length has been set to zero" -msgstr "" +msgstr "%L处的CHARACTER 变量有负的长度 %d，长度已经被设为零" #: fortran/resolve.c:8599 #, gcc-internal-format @@ -35415,7 +35402,7 @@ msgstr "‘%s’在%L处不能是主机相关的，因为它被在%L处声明的 #: fortran/resolve.c:8964 #, gcc-internal-format msgid "Fortran 2008: Implied SAVE for module variable '%s' at %L, needed due to the default initialization" -msgstr "" +msgstr "Fortran 2008：%2$L处模块变量‘%1$s’隐含使用了 SAVE，因为默认初始化有此需求" #: fortran/resolve.c:8975 #, gcc-internal-format diff --git a/gcc/reginfo.c b/gcc/reginfo.c index ee6c7ee6447..bf43d702da5 100644 --- a/gcc/reginfo.c +++ b/gcc/reginfo.c @@ -666,6 +666,8 @@ void reinit_regs (void) { init_regs (); + /* caller_save needs to be re-initialized. */ + caller_save_initialized_p = false; ira_init (); } diff --git a/gcc/rtl.h b/gcc/rtl.h index b8563b33d16..ccb3c1a044a 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -1627,6 +1627,7 @@ extern void start_sequence (void); extern void push_to_sequence (rtx); extern void push_to_sequence2 (rtx, rtx); extern void end_sequence (void); +extern rtx immed_double_int_const (double_int, enum machine_mode); extern rtx immed_double_const (HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode); diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c index d189d7066f2..fbbf7ad5e12 100644 --- a/gcc/simplify-rtx.c +++ b/gcc/simplify-rtx.c @@ -1770,44 +1770,42 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, if (SCALAR_INT_MODE_P (mode)) { - HOST_WIDE_INT coeff0h = 0, coeff1h = 0; - unsigned HOST_WIDE_INT coeff0l = 1, coeff1l = 1; + double_int coeff0, coeff1; rtx lhs = op0, rhs = op1; + coeff0 = double_int_one; + coeff1 = double_int_one; + if (GET_CODE (lhs) == NEG) { - coeff0l = -1; - coeff0h = -1; + coeff0 = double_int_minus_one; lhs = XEXP (lhs, 0); } else if (GET_CODE (lhs) == MULT && CONST_INT_P (XEXP (lhs, 1))) { - coeff0l = INTVAL (XEXP (lhs, 1)); - coeff0h = INTVAL (XEXP (lhs, 1)) < 0 ? -1 : 0; + coeff0 = shwi_to_double_int (INTVAL (XEXP (lhs, 1))); lhs = XEXP (lhs, 0); } else if (GET_CODE (lhs) == ASHIFT && CONST_INT_P (XEXP (lhs, 1)) - && INTVAL (XEXP (lhs, 1)) >= 0 + && INTVAL (XEXP (lhs, 1)) >= 0 && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT) { - coeff0l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1)); - coeff0h = 0; + coeff0 = double_int_setbit (double_int_zero, + INTVAL (XEXP (lhs, 1))); lhs = XEXP (lhs, 0); } if (GET_CODE (rhs) == NEG) { - coeff1l = -1; - coeff1h = -1; + coeff1 = double_int_minus_one; rhs = XEXP (rhs, 0); } else if (GET_CODE (rhs) == MULT && CONST_INT_P (XEXP (rhs, 1))) { - coeff1l = INTVAL (XEXP (rhs, 1)); - coeff1h = INTVAL (XEXP (rhs, 1)) < 0 ? -1 : 0; + coeff1 = shwi_to_double_int (INTVAL (XEXP (rhs, 1))); rhs = XEXP (rhs, 0); } else if (GET_CODE (rhs) == ASHIFT @@ -1815,8 +1813,8 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, && INTVAL (XEXP (rhs, 1)) >= 0 && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT) { - coeff1l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1)); - coeff1h = 0; + coeff1 = double_int_setbit (double_int_zero, + INTVAL (XEXP (rhs, 1))); rhs = XEXP (rhs, 0); } @@ -1824,12 +1822,11 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, { rtx orig = gen_rtx_PLUS (mode, op0, op1); rtx coeff; - unsigned HOST_WIDE_INT l; - HOST_WIDE_INT h; + double_int val; bool speed = optimize_function_for_speed_p (cfun); - add_double (coeff0l, coeff0h, coeff1l, coeff1h, &l, &h); - coeff = immed_double_const (l, h, mode); + val = double_int_add (coeff0, coeff1); + coeff = immed_double_int_const (val, mode); tem = simplify_gen_binary (MULT, mode, lhs, coeff); return rtx_cost (tem, SET, speed) <= rtx_cost (orig, SET, speed) @@ -1953,21 +1950,21 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, if (SCALAR_INT_MODE_P (mode)) { - HOST_WIDE_INT coeff0h = 0, negcoeff1h = -1; - unsigned HOST_WIDE_INT coeff0l = 1, negcoeff1l = -1; + double_int coeff0, negcoeff1; rtx lhs = op0, rhs = op1; + coeff0 = double_int_one; + negcoeff1 = double_int_minus_one; + if (GET_CODE (lhs) == NEG) { - coeff0l = -1; - coeff0h = -1; + coeff0 = double_int_minus_one; lhs = XEXP (lhs, 0); } else if (GET_CODE (lhs) == MULT && CONST_INT_P (XEXP (lhs, 1))) { - coeff0l = INTVAL (XEXP (lhs, 1)); - coeff0h = INTVAL (XEXP (lhs, 1)) < 0 ? -1 : 0; + coeff0 = shwi_to_double_int (INTVAL (XEXP (lhs, 1))); lhs = XEXP (lhs, 0); } else if (GET_CODE (lhs) == ASHIFT @@ -1975,22 +1972,20 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, && INTVAL (XEXP (lhs, 1)) >= 0 && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT) { - coeff0l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1)); - coeff0h = 0; + coeff0 = double_int_setbit (double_int_zero, + INTVAL (XEXP (lhs, 1))); lhs = XEXP (lhs, 0); } if (GET_CODE (rhs) == NEG) { - negcoeff1l = 1; - negcoeff1h = 0; + negcoeff1 = double_int_one; rhs = XEXP (rhs, 0); } else if (GET_CODE (rhs) == MULT && CONST_INT_P (XEXP (rhs, 1))) { - negcoeff1l = -INTVAL (XEXP (rhs, 1)); - negcoeff1h = INTVAL (XEXP (rhs, 1)) <= 0 ? 0 : -1; + negcoeff1 = shwi_to_double_int (-INTVAL (XEXP (rhs, 1))); rhs = XEXP (rhs, 0); } else if (GET_CODE (rhs) == ASHIFT @@ -1998,8 +1993,9 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, && INTVAL (XEXP (rhs, 1)) >= 0 && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT) { - negcoeff1l = -(((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1))); - negcoeff1h = -1; + negcoeff1 = double_int_setbit (double_int_zero, + INTVAL (XEXP (rhs, 1))); + negcoeff1 = double_int_neg (negcoeff1); rhs = XEXP (rhs, 0); } @@ -2007,12 +2003,11 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, { rtx orig = gen_rtx_MINUS (mode, op0, op1); rtx coeff; - unsigned HOST_WIDE_INT l; - HOST_WIDE_INT h; + double_int val; bool speed = optimize_function_for_speed_p (cfun); - add_double (coeff0l, coeff0h, negcoeff1l, negcoeff1h, &l, &h); - coeff = immed_double_const (l, h, mode); + val = double_int_add (coeff0, negcoeff1); + coeff = immed_double_int_const (val, mode); tem = simplify_gen_binary (MULT, mode, lhs, coeff); return rtx_cost (tem, SET, speed) <= rtx_cost (orig, SET, speed) diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c index 46ac3339803..151092c06a4 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -2214,37 +2214,35 @@ make_accum_type (int precision, int unsignedp, int satp) value to enable integer types to be created. */ void -initialize_sizetypes (bool signed_p) +initialize_sizetypes (void) { tree t = make_node (INTEGER_TYPE); int precision = GET_MODE_BITSIZE (SImode); SET_TYPE_MODE (t, SImode); TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode); - TYPE_USER_ALIGN (t) = 0; TYPE_IS_SIZETYPE (t) = 1; - TYPE_UNSIGNED (t) = !signed_p; + TYPE_UNSIGNED (t) = 1; TYPE_SIZE (t) = build_int_cst (t, precision); TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode)); TYPE_PRECISION (t) = precision; - /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE. */ - set_min_and_max_values_for_integral_type (t, precision, !signed_p); + set_min_and_max_values_for_integral_type (t, precision, true); sizetype = t; bitsizetype = build_distinct_type_copy (t); } -/* Make sizetype a version of TYPE, and initialize *sizetype - accordingly. We do this by overwriting the stub sizetype and - bitsizetype nodes created by initialize_sizetypes. This makes sure - that (a) anything stubby about them no longer exists, (b) any - INTEGER_CSTs created with such a type, remain valid. */ +/* Make sizetype a version of TYPE, and initialize *sizetype accordingly. + We do this by overwriting the stub sizetype and bitsizetype nodes created + by initialize_sizetypes. This makes sure that (a) anything stubby about + them no longer exists and (b) any INTEGER_CSTs created with such a type, + remain valid. */ void set_sizetype (tree type) { - tree t; + tree t, max; int oprecision = TYPE_PRECISION (type); /* The *bitsizetype types use a precision that avoids overflows when calculating signed sizes / offsets in bits. However, when @@ -2257,11 +2255,11 @@ set_sizetype (tree type) if (precision > HOST_BITS_PER_WIDE_INT * 2) precision = HOST_BITS_PER_WIDE_INT * 2; - gcc_assert (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype)); + /* sizetype must be an unsigned type. */ + gcc_assert (TYPE_UNSIGNED (type)); t = build_distinct_type_copy (type); - /* We do want to use sizetype's cache, as we will be replacing that - type. */ + /* We want to use sizetype's cache, as we will be replacing that type. */ TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (sizetype); TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (sizetype); TREE_TYPE (TYPE_CACHED_VALUES (t)) = type; @@ -2273,10 +2271,17 @@ set_sizetype (tree type) TYPE_MAIN_VARIANT (sizetype) = sizetype; TYPE_CANONICAL (sizetype) = sizetype; + /* sizetype is unsigned but we need to fix TYPE_MAX_VALUE so that it is + sign-extended in a way consistent with force_fit_type. */ + max = TYPE_MAX_VALUE (sizetype); + TYPE_MAX_VALUE (sizetype) + = build_int_cst_wide_type (sizetype, + TREE_INT_CST_LOW (max), + TREE_INT_CST_HIGH (max)); + t = make_node (INTEGER_TYPE); TYPE_NAME (t) = get_identifier ("bit_size_type"); - /* We do want to use bitsizetype's cache, as we will be replacing that - type. */ + /* We want to use bitsizetype's cache, as we will be replacing that type. */ TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (bitsizetype); TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (bitsizetype); TYPE_PRECISION (t) = precision; @@ -2288,36 +2293,13 @@ set_sizetype (tree type) TYPE_MAIN_VARIANT (bitsizetype) = bitsizetype; TYPE_CANONICAL (bitsizetype) = bitsizetype; - if (TYPE_UNSIGNED (type)) - { - fixup_unsigned_type (bitsizetype); - ssizetype = make_signed_type (oprecision); - TYPE_IS_SIZETYPE (ssizetype) = 1; - sbitsizetype = make_signed_type (precision); - TYPE_IS_SIZETYPE (sbitsizetype) = 1; - } - else - { - fixup_signed_type (bitsizetype); - ssizetype = sizetype; - sbitsizetype = bitsizetype; - } - - /* If SIZETYPE is unsigned, we need to fix TYPE_MAX_VALUE so that - it is sign extended in a way consistent with force_fit_type. */ - if (TYPE_UNSIGNED (type)) - { - tree orig_max, new_max; + fixup_unsigned_type (bitsizetype); - orig_max = TYPE_MAX_VALUE (sizetype); - - /* Build a new node with the same values, but a different type. - Sign extend it to ensure consistency. */ - new_max = build_int_cst_wide_type (sizetype, - TREE_INT_CST_LOW (orig_max), - TREE_INT_CST_HIGH (orig_max)); - TYPE_MAX_VALUE (sizetype) = new_max; - } + /* Create the signed variants of *sizetype. */ + ssizetype = make_signed_type (oprecision); + TYPE_IS_SIZETYPE (ssizetype) = 1; + sbitsizetype = make_signed_type (precision); + TYPE_IS_SIZETYPE (sbitsizetype) = 1; } /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index b58bb508e88..d057d15e267 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,191 @@ +2010-04-22 Uros Bizjak + + * gcc.dg/graphite/interchange-0.c: Fix dg-final directive. + +2010-04-22 Ira Rosen + + PR tree-optimization/43842 + * gcc.dg/vect/pr43842.c: New test. + +2010-04-22 Bernd Schmidt + + * gcc.target/i386/wmul-1.c: Add dg-require-effective-target ilp32. + * gcc.target/i386/wmul-2.c: Likewise. + +2010-04-22 Kaveh R. Ghazi + + * gcc.dg/torture/builtin-cproj-3.c: Rename and move ... + * gcc.dg/cproj-fails-with-broken-glibc.c: ... to here. + +2010-04-22 Alexander Monakov + + * gfortran.dg/reassoc_6.f: New testcase. + +2010-04-22 Bernd Schmidt + + PR middle-end/29274 + * gcc.target/arm/wmul-1.c: New test. + * gcc.target/arm/wmul-2.c: New test. + +2010-04-22 Richard Guenther + + PR tree-optimization/43845 + * gcc.c-torture/compile/pr43845.c: New testcase. + +2010-04-22 Bernd Schmidt + + PR middle-end/29274 + * gcc.target/i386/wmul-1.c: New test. + * gcc.target/i386/wmul-2.c: New test. + * gcc.target/bfin/wmul-1.c: New test. + * gcc.target/bfin/wmul-2.c: New test. + +2010-04-22 Richard Guenther + + PR fortran/43829 + * gfortran.dg/vector_subscript_6.f90: New testcase. + * gfortran.dg/assign_10.f90: Adjust. + +2010-04-21 Jakub Jelinek + + PR fortran/43836 + * gfortran.dg/gomp/pr43836.f90: New test. + +2010-04-21 Richard Guenther + + * gcc.dg/ipa/ipa-pta-11.c: Adjust. + +2010-04-21 Kaveh R. Ghazi + + * gcc.dg/torture/builtin-cproj-3.c: New. + +2010-04-20 Jason Merrill + + PR c++/9335 + * g++.dg/template/recurse2.C: New. + * g++.dg/parse/crash36.C: Adjust. + * g++.dg/other/fold1.C: Adjust. + * g++.dg/init/member1.C: Adjust. + * lib/prune.exp: Prune "skipping N instantiation contexts". + +2010-04-20 Kaveh R. Ghazi + + * gcc.dg/torture/builtin-cproj-1.c: Test more cases. + +2010-04-20 Kaveh R. Ghazi + + * gcc.dg/torture/builtin-cproj-1.c: New. + * gcc.dg/torture/builtin-cproj-2.c: New. + +2010-04-20 Dodji Seketeli + + PR c++/43800 + PR c++/43704 + * g++.dg/template/typedef32.C: Adjust. + * g++.dg/template/typedef33.C: New test. + +2010-04-20 Paul Thomas + + PR fortran/43227 + * gfortran.dg/proc_decl_23.f90: New test. + + PR fortran/43266 + * gfortran.dg/abstract_type_6.f03: New test. + +2010-04-20 Xinliang David Li + + * g++.dg/tree-ssa/fold-compare.C: New. + +2010-04-20 Richard Guenther + + PR tree-optimization/39417 + * g++.dg/torture/pr39417.C: New testcase. + +2010-04-20 Richard Guenther + + * gcc.dg/ipa/ipa-pta-14.c: New testcase. + +2010-04-20 Jakub Jelinek + + * g++.dg/debug/dwarf2/rv1.C: New test. + +2010-04-20 Andreas Krebbel + + PR target/43635 + * gcc.c-torture/compile/pr43635.c: New testcase. + +2010-04-19 Jakub Jelinek + + PR fortran/43339 + * gfortran.dg/gomp/sharing-2.f90: Adjust for iteration vars + of sequential loops being private only in the innermost containing + task region. + + PR middle-end/43337 + * gfortran.dg/gomp/pr43337.f90: New test. + +2010-04-19 Richard Guenther + + PR tree-optimization/43796 + * gfortran.dg/pr43796.f90: New testcase. + +2010-04-19 Richard Guenther + + PR tree-optimization/43783 + * gcc.c-torture/execute/pr43783.c: New testcase. + +2010-04-19 Uros Bizjak + + PR target/43766 + * gcc.target/i386/pr43766.c: New test. + +2010-04-19 Jie Zhang + + PR target/43662 + * gcc.target/i386/pr43662.c: New test. + +2010-04-19 Dodji Seketeli + + PR c++/43704 + * g++.dg/template/typedef32.C: New test. + +2010-04-19 Ira Rosen + + PR tree-optimization/37027 + * lib/target-supports.exp + (check_effective_target_vect_widen_sum_hi_to_si_pattern): New. + * gcc.dg/vect/pr37027.c: New test. + * gcc.dg/vect/slp-reduc-1.c, gcc.dg/vect/slp-reduc-2.c, + gcc.dg/vect/slp-reduc-3.c, gcc.dg/vect/slp-reduc-4.c, + gcc.dg/vect/slp-reduc-5.c, gcc.dg/vect/slp-reduc-6.c, + gcc.dg/vect/vect-complex-6.c: Likewise. + +2010-04-19 Jakub Jelinek + + * g++.dg/debug/dwarf2/enum1.C: New test. + +2010-04-18 Eric Botcazou + + * gnat.dg/rep_clause5.ad[sb]: New test. + * gnat.dg/rep_clause5_pkg.ads: New helper. + +2010-04-18 Ira Rosen + + PR tree-optimization/43771 + * g++.dg/vect/pr43771.cc: New test. + +2010-04-17 Steven G. Kargl + + PR fortran/31538 + * gfortran.dg/bounds_check_fail_4.f90: Adjust error message. + * gfortran.dg/bounds_check_fail_3.f90: Ditto. + +2010-04-17 Eric Botcazou + + * gnat.dg/sizetype.adb: Rename into... + * gnat.dg/sizetype1.adb: ...this. + * gnat.dg/sizetype2.adb: New test. + 2010-04-16 Richard Guenther PR tree-optimization/43572 @@ -2112,7 +2300,7 @@ * g++.dg/cpp0x/initlist-opt.C: Declare max_val inline. -2010-02-16 Ira Rosen +2010-02-16 Ira Rosen PR tree-optimization/43074 * gcc.dg/vect/fast-math-pr43074.c: New test. diff --git a/gcc/testsuite/g++.dg/debug/dwarf2/enum1.C b/gcc/testsuite/g++.dg/debug/dwarf2/enum1.C new file mode 100644 index 00000000000..b5518ef18a0 --- /dev/null +++ b/gcc/testsuite/g++.dg/debug/dwarf2/enum1.C @@ -0,0 +1,19 @@ +// { dg-do compile } +// { dg-options "-g -dA -gno-strict-dwarf -std=c++0x" } +// { dg-final { scan-assembler-times "DIE\[^\n\r\]*DW_TAG_enumeration_type" 3 } } +// { dg-final { scan-assembler-times " DW_AT_enum_class" 2 } } + +enum A { a1, a2 } a; +enum struct B { b1, b2 } b; +enum class C { c1, c2 } c; + +void +foo () +{ + a = a1; + a = A::a2; + b = B::b1; + b = B::b2; + c = C::c1; + c = C::c2; +} diff --git a/gcc/testsuite/g++.dg/debug/dwarf2/rv1.C b/gcc/testsuite/g++.dg/debug/dwarf2/rv1.C new file mode 100644 index 00000000000..c954daa91a4 --- /dev/null +++ b/gcc/testsuite/g++.dg/debug/dwarf2/rv1.C @@ -0,0 +1,15 @@ +// { dg-do compile } +// { dg-options "-g -dA -gdwarf-4 -std=c++0x" } +// { dg-final { scan-assembler-times "DIE\[^\n\r\]*DW_TAG_reference_type" 1 } } +// { dg-final { scan-assembler-times "DIE\[^\n\r\]*DW_TAG_rvalue_reference_type" 1 } } + +struct A { A (); ~A (); }; +struct B { B (); ~B (); }; + +void +foo () +{ + A v; + A &a = v; + B &&b = B (); +} diff --git a/gcc/testsuite/g++.dg/init/member1.C b/gcc/testsuite/g++.dg/init/member1.C index e2af0809c71..aededf23e7b 100644 --- a/gcc/testsuite/g++.dg/init/member1.C +++ b/gcc/testsuite/g++.dg/init/member1.C @@ -11,7 +11,7 @@ template struct B {}; template struct C { static const int i = A::i; // { dg-error "incomplete" } - static const int j = i; // { dg-error "non-constant expression" } + static const int j = i; B b; // { dg-error "not a valid template arg" } }; diff --git a/gcc/testsuite/g++.dg/other/fold1.C b/gcc/testsuite/g++.dg/other/fold1.C index b085a84f0dd..b075fc10c80 100644 --- a/gcc/testsuite/g++.dg/other/fold1.C +++ b/gcc/testsuite/g++.dg/other/fold1.C @@ -4,5 +4,5 @@ struct A { static const int i = i; // { dg-error "not declared" } - int x[i]; // { dg-error "integral constant-expression" } + int x[i]; }; diff --git a/gcc/testsuite/g++.dg/parse/crash36.C b/gcc/testsuite/g++.dg/parse/crash36.C index 6f5c86734a8..6116eb0f9eb 100644 --- a/gcc/testsuite/g++.dg/parse/crash36.C +++ b/gcc/testsuite/g++.dg/parse/crash36.C @@ -9,4 +9,4 @@ template struct A // { dg-warning "variadic templates" } static const int i = sizeof (++t); // { dg-error "was not declared in this scope" } }; -int x[A ::i]; // { dg-error "is not an integral constant-expression" } +int x[A ::i]; diff --git a/gcc/testsuite/g++.dg/template/recurse2.C b/gcc/testsuite/g++.dg/template/recurse2.C new file mode 100644 index 00000000000..cf085e0d553 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/recurse2.C @@ -0,0 +1,7 @@ +// PR c++/9335 +// We should not see an error about non-constant initialization. + +template struct X { + static const int value = X::value; // { dg-error "instantiation|incomplete" } +}; +template struct X<1000>; diff --git a/gcc/testsuite/g++.dg/template/typedef32.C b/gcc/testsuite/g++.dg/template/typedef32.C new file mode 100644 index 00000000000..b32e66c3f88 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/typedef32.C @@ -0,0 +1,46 @@ +// Origin: PR c++/43704 +// { dg-do compile } + +template +struct if_ +{ + typedef T2 type; +}; + +template +struct iterator_restrict_traits +{ + struct iterator_category {}; +}; + +template +struct matrix +{ + struct ci {struct ic {};}; + class i {}; +}; + +template +struct triangular_adaptor +{ + typedef typename if_::type ty1; + class iterator2 : iterator_restrict_traits::iterator_category + { + }; +}; + +template +struct banded_adaptor +{ + typedef typename if_::type ty1; + class iterator1 : iterator_restrict_traits::iterator_category + { + }; +}; + +template +struct singular_decomposition +{ + banded_adaptor >::iterator1 it1; +}; + diff --git a/gcc/testsuite/g++.dg/template/typedef33.C b/gcc/testsuite/g++.dg/template/typedef33.C new file mode 100644 index 00000000000..1d2117b3a41 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/typedef33.C @@ -0,0 +1,21 @@ +// Origin PR c++/43800 +// { dg-do compile } + +template +struct V +{ + typedef T t_type; +}; + +template +class J +{ + typedef typename V::t_type t_type; + const t_type& f(); // #0: +private: + t_type b; +}; + +template +const typename V::t_type& J::f() {return b;} // #1 + diff --git a/gcc/testsuite/g++.dg/torture/pr39417.C b/gcc/testsuite/g++.dg/torture/pr39417.C new file mode 100644 index 00000000000..b7bbb88b784 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr39417.C @@ -0,0 +1,56 @@ +// { dg-do run } + +#include + +std::vector +sequence(int l, int n) +{ + std::vector ret; + for(int i=n;i<=100;i++) + { + if(i%2==0) + { + if(l%i==i/2) + { + int init =l/i-i/2+1; + if(init>=0) + { + for(int j=0;j=0) + { + for(int j=0;j res = sequence(18, 2); + if (res.size () != 3 + || res[0] != 5 + || res[1] != 6 + || res[2] != 7) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/tree-ssa/fold-compare.C b/gcc/testsuite/g++.dg/tree-ssa/fold-compare.C new file mode 100644 index 00000000000..2b4c41103ba --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/fold-compare.C @@ -0,0 +1,28 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +struct ExtentsBase { + ExtentsBase() : startx_(), endx_() { } + ExtentsBase(const ExtentsBase &b) { + *this = b; + } + + const ExtentsBase & operator=(const ExtentsBase &b) { + if (this != &b) { + startx_ = b.startx_; + } + return *this; + } + + int startx_; + int endx_; +}; + +int f(const ExtentsBase &e1) { + ExtentsBase my_extents = e1; + return my_extents.startx_; +} + +/* { dg-final { scan-tree-dump-not "&my_extents" "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ + diff --git a/gcc/testsuite/g++.dg/vect/pr43771.cc b/gcc/testsuite/g++.dg/vect/pr43771.cc new file mode 100644 index 00000000000..1a2d09aae93 --- /dev/null +++ b/gcc/testsuite/g++.dg/vect/pr43771.cc @@ -0,0 +1,14 @@ +/* { dg-do compile } */ + +void KWayNodeRefine__(int nparts, int *gpwgts, int *badminpwgt, int +*badmaxpwgt) +{ + int i; + + for (i=0; issd(); + return i_ssd; +} diff --git a/gcc/testsuite/gcc.c-torture/execute/pr43783.c b/gcc/testsuite/gcc.c-torture/execute/pr43783.c new file mode 100644 index 00000000000..3880026c405 --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/execute/pr43783.c @@ -0,0 +1,21 @@ +typedef __attribute__((aligned(16))) +struct { + unsigned long long w[3]; +} UINT192; + +UINT192 bid_Kx192[32]; + +extern void abort (void); + +int main() +{ + int i = 0; + unsigned long x = 0; + for (i = 0; i < 32; ++i) + bid_Kx192[i].w[1] = i == 1; + for (i = 0; i < 32; ++i) + x += bid_Kx192[1].w[1]; + if (x != 32) + abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/cproj-fails-with-broken-glibc.c b/gcc/testsuite/gcc.dg/cproj-fails-with-broken-glibc.c new file mode 100644 index 00000000000..fe143b9ea5b --- /dev/null +++ b/gcc/testsuite/gcc.dg/cproj-fails-with-broken-glibc.c @@ -0,0 +1,25 @@ +/* Copyright (C) 2010 Free Software Foundation. + + Check the runtime behavior of the C library's cproj() function and + whether it follows the standard. Versions of GLIBC through 2.11.1 + had an incorrect implementation which will conflict with GCC's + builtin cproj(). GLIBC 2.12+ should be okay. + + Origin: Kaveh R. Ghazi, April 20, 2010. */ + +/* { dg-do run } */ +/* { dg-options "-fno-builtin-cproj" } */ +/* { dg-add-options c99_runtime } */ +/* { dg-require-effective-target c99_runtime } */ + +extern void abort(void); +extern void exit(int); +double _Complex cproj(double _Complex); + +int main (void) +{ + if (cproj (2+3i) != 2+3i) + abort(); + + exit(0); +} diff --git a/gcc/testsuite/gcc.dg/graphite/interchange-0.c b/gcc/testsuite/gcc.dg/graphite/interchange-0.c index b6e382c0a6f..8bc6e132664 100644 --- a/gcc/testsuite/gcc.dg/graphite/interchange-0.c +++ b/gcc/testsuite/gcc.dg/graphite/interchange-0.c @@ -47,4 +47,4 @@ main (void) } /* { dg-final { scan-tree-dump-times "will be interchanged" 1 "graphite" } } */ -/* { dg -final { cleanup-tree-dump "graphite" } } */ +/* { dg-final { cleanup-tree-dump "graphite" } } */ diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-pta-11.c b/gcc/testsuite/gcc.dg/ipa/ipa-pta-11.c index 947ab816fc9..6ef7438dd6b 100644 --- a/gcc/testsuite/gcc.dg/ipa/ipa-pta-11.c +++ b/gcc/testsuite/gcc.dg/ipa/ipa-pta-11.c @@ -29,5 +29,5 @@ int main() /* It isn't clear if the escape if l is strictly necessary, if it were we should have i, r and s in ESCAPED as well. */ -/* { dg-final { scan-ipa-dump "ESCAPED = { ESCAPED NONLOCAL l k }" "pta" } } */ +/* { dg-final { scan-ipa-dump "ESCAPED = { l k }" "pta" } } */ /* { dg-final { cleanup-ipa-dump "pta" } } */ diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-pta-14.c b/gcc/testsuite/gcc.dg/ipa/ipa-pta-14.c new file mode 100644 index 00000000000..ffe16ccc358 --- /dev/null +++ b/gcc/testsuite/gcc.dg/ipa/ipa-pta-14.c @@ -0,0 +1,32 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -fipa-pta -fno-tree-sra -fdump-ipa-pta-details" } */ + +struct X { + int i; + void *p; +}; + +static void * __attribute__((noinline,noclone)) +foo(struct X *q, void *p) +{ + struct X b; + b.p = p; + *q = b; + return q->p; +} +extern void abort (void); +int main() +{ + struct X a, c; + void *p; + a.p = (void *)&c; + p = foo(&a, &a); + /* { dg-final { scan-ipa-dump "foo.result = { NULL a c }" "pta" { xfail *-*-* } } } */ + /* { dg-final { scan-ipa-dump "foo.result = { NULL a a\[^ \]* c }" "pta" } } */ + ((struct X *)p)->p = (void *)0; + if (a.p != (void *)0) + abort (); + return 0; +} + +/* { dg-final { cleanup-ipa-dump "pta" } } */ diff --git a/gcc/testsuite/gcc.dg/torture/builtin-cproj-1.c b/gcc/testsuite/gcc.dg/torture/builtin-cproj-1.c new file mode 100644 index 00000000000..31cd5874ffb --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/builtin-cproj-1.c @@ -0,0 +1,175 @@ +/* Copyright (C) 2010 Free Software Foundation. + + Verify that folding of built-in cproj is correctly performed by the + compiler. + + Origin: Kaveh R. Ghazi, April 9, 2010. */ + +/* { dg-do link } */ + +/* All references to link_error should go away at compile-time. The + argument is the __LINE__ number. It appears in the tree dump file + and aids in debugging should any of the tests fail. */ +extern void link_error(int); + +#define CPROJ(X) __builtin_cproj(X) +#define CPROJF(X) __builtin_cprojf(X) +#define CPROJL(X) __builtin_cprojl(X) +#define INF __builtin_inff() +#define I 1i +#define CPSGN(X,Y) __builtin_copysignf((X),(Y)) +#define CIMAG(X) __builtin_cimagf(X) +#define CREAL(X) __builtin_crealf(X) + +/* Check that the signs of the real and/or imaginary parts of two + complex numbers match. */ +#define CKSGN(X,Y) (CKSGN_R(X,Y) || CKSGN_I(X,Y)) +#define CKSGN_R(X,Y) (CPSGN(1,CREAL(X)) != CPSGN(1,CREAL(Y))) +#define CKSGN_I(X,Y) (CPSGN(1,CIMAG(X)) != CPSGN(1,CIMAG(Y))) + +/* Test that (cproj(X) == ZERO+Inf) and that the signs of the + imaginary parts match. ZERO is +/- 0i. */ +#define TEST_CST_INF(X,ZERO) do { \ + if (CPROJF(X) != ZERO+INF || CKSGN_I(CPROJF(X),ZERO+INF)) \ + link_error(__LINE__); \ + if (CPROJ(X) != ZERO+INF || CKSGN_I(CPROJ(X),ZERO+INF)) \ + link_error(__LINE__); \ + if (CPROJL(X) != ZERO+INF || CKSGN_I(CPROJL(X),ZERO+INF)) \ + link_error(__LINE__); \ +} while (0) + +/* Test that (cproj(X) == X) for all finite (X). */ +#define TEST_CST(X) do { \ + if (CPROJF(X) != (X) || CKSGN(CPROJF(X),(X))) \ + link_error(__LINE__); \ +} while (0) + +/* Test that cproj(X + I*INF) -> (ZERO + INF), where ZERO is +-0i. + NEG is either blank or a minus sign when ZERO is negative. */ +#define TEST_IMAG_INF(NEG,ZERO) do { \ + if (CPROJF(f+I*NEG INF) != ZERO+INF \ + || CKSGN_I (CPROJF(f+I*NEG INF), ZERO+INF)) \ + link_error(__LINE__); \ + if (CPROJ(d+I*NEG INF) != ZERO+INF \ + || CKSGN_I (CPROJ(d+I*NEG INF), ZERO+INF)) \ + link_error(__LINE__); \ + if (CPROJL(ld+I*NEG INF) != ZERO+INF \ + || CKSGN_I (CPROJL(ld+I*NEG INF), ZERO+INF)) \ + link_error(__LINE__); \ +} while (0) + +/* Like TEST_IMAG_INF, but check that side effects are honored. */ +#define TEST_IMAG_INF_SIDE_EFFECT(NEG,ZERO) do { \ + int side = 4; \ + if (CPROJF(++side+I*NEG INF) != ZERO+INF \ + || CKSGN_I (CPROJF(++side+I*NEG INF), ZERO+INF)) \ + link_error(__LINE__); \ + if (CPROJ(++side+I*NEG INF) != ZERO+INF \ + || CKSGN_I (CPROJ(++side+I*NEG INF), ZERO+INF)) \ + link_error(__LINE__); \ + if (CPROJL(++side+I*NEG INF) != ZERO+INF \ + || CKSGN_I (CPROJL(++side+I*NEG INF), ZERO+INF)) \ + link_error(__LINE__); \ + if (side != 10) \ + link_error(__LINE__); \ +} while (0) + +/* Test that cproj(INF, POSITIVE) -> INF+0i. NEG is either blank or a + minus sign to test negative INF. */ +#define TEST_REAL_INF(NEG) do { \ + __real cf = NEG INF; \ + __imag cf = (x ? 4 : 5); \ + if (CPROJF(cf) != INF \ + || CKSGN_I (CPROJF(cf), INF)) \ + link_error(__LINE__); \ + __real cd = NEG INF; \ + __imag cd = (x ? 4 : 5); \ + if (CPROJ(cd) != INF \ + || CKSGN_I (CPROJ(cd), INF)) \ + link_error(__LINE__); \ + __real cld = NEG INF; \ + __imag cld = (x ? 4 : 5); \ + if (CPROJL(cld) != INF \ + || CKSGN_I (CPROJL(cld), INF)) \ + link_error(__LINE__); \ +} while (0) + +/* Like TEST_REAL_INF, but check that side effects are honored. */ +#define TEST_REAL_INF_SIDE_EFFECT(NEG) do { \ + int side = -9; \ + __real cf = NEG INF; \ + __imag cf = (x ? 4 : 5); \ + if (CPROJF((++side,cf)) != INF \ + || CKSGN_I (CPROJF((++side,cf)), INF)) \ + link_error(__LINE__); \ + __real cd = NEG INF; \ + __imag cd = (x ? 4 : 5); \ + if (CPROJ((++side,cd)) != INF \ + || CKSGN_I (CPROJ((++side,cd)), INF)) \ + link_error(__LINE__); \ + __real cld = NEG INF; \ + __imag cld = (x ? 4 : 5); \ + if (CPROJL((++side,cld)) != INF \ + || CKSGN_I (CPROJL((++side,cld)), INF)) \ + link_error(__LINE__); \ + if (side != -3) \ + link_error(__LINE__); \ +} while (0) + +void foo (_Complex long double cld, _Complex double cd, _Complex float cf, + long double ld, double d, float f, int x) +{ + TEST_CST_INF (INF+0I, 0); + TEST_CST_INF (INF-0I, -0.FI); + TEST_CST_INF (INF+4I, 0); + TEST_CST_INF (INF-4I, -0.FI); + TEST_CST_INF (-INF+0I, 0); + TEST_CST_INF (-INF-0I, -0.FI); + TEST_CST_INF (-INF+4I, 0); + TEST_CST_INF (-INF-4I, -0.FI); + + TEST_CST_INF (0+I*INF, 0); + TEST_CST_INF (0-I*INF, -0.FI); + TEST_CST_INF (23+I*INF, 0); + TEST_CST_INF (23-I*INF, -0.FI); + TEST_CST_INF (-0.F+I*INF, 0); + TEST_CST_INF (-0.F-I*INF, -0.FI); + TEST_CST_INF (-23+I*INF, 0); + TEST_CST_INF (-23-I*INF, -0.FI); + + TEST_CST_INF (INF+I*INF, 0); + TEST_CST_INF (INF-I*INF, -0.FI); + TEST_CST_INF (-INF+I*INF, 0); + TEST_CST_INF (-INF-I*INF, -0.FI); + + TEST_CST (0); + TEST_CST (-0.F); + TEST_CST (0-0.FI); + TEST_CST (-0.F-0.FI); + + TEST_CST (22+3I); + TEST_CST (22-3I); + TEST_CST (-22+3I); + TEST_CST (-22-3I); + + TEST_IMAG_INF (,0.FI); + TEST_IMAG_INF (-,-0.FI); + +#ifdef __OPTIMIZE__ + TEST_REAL_INF( ); + TEST_REAL_INF(-); + + TEST_IMAG_INF_SIDE_EFFECT (,0.FI); + TEST_IMAG_INF_SIDE_EFFECT (-,-0.FI); + + TEST_REAL_INF_SIDE_EFFECT( ); + TEST_REAL_INF_SIDE_EFFECT(-); +#endif + + return; +} + +int main (void) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/builtin-cproj-2.c b/gcc/testsuite/gcc.dg/torture/builtin-cproj-2.c new file mode 100644 index 00000000000..39331651f19 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/builtin-cproj-2.c @@ -0,0 +1,46 @@ +/* Copyright (C) 2010 Free Software Foundation. + + Verify that folding of built-in cproj is correctly performed by the + compiler. With -ffinite-math-only all cproj calls should be + eliminated regardless of what the argument is, or what is known + about it. + + Origin: Kaveh R. Ghazi, April 9, 2010. */ + +/* { dg-do link } */ +/* { dg-options "-ffinite-math-only" } */ + +/* All references to link_error should go away at compile-time. The + argument is the __LINE__ number. It appears in the tree dump file + and aids in debugging should any of the tests fail. */ +extern void link_error(int); + +#define CPROJ(X) __builtin_cproj(X) +#define CPROJF(X) __builtin_cprojf(X) +#define CPROJL(X) __builtin_cprojl(X) + +/* Test that the supplied expressions eliminte the cproj call. */ +#define TEST_EXPRS(LD_EXPR, D_EXPR, F_EXPR) do { \ + if (CPROJF(F_EXPR) != (F_EXPR)) \ + link_error (__LINE__); \ + if (CPROJ(D_EXPR) != (D_EXPR)) \ + link_error (__LINE__); \ + if (CPROJL(LD_EXPR) != (LD_EXPR)) \ + link_error (__LINE__); \ +} while (0) + +void foo (_Complex long double cld, _Complex double cd, _Complex float cf) +{ +#ifdef __OPTIMIZE__ + TEST_EXPRS (cld, cd, cf); + TEST_EXPRS (cld*2, cd*2, cf*2); + TEST_EXPRS (cld*cld, cd*cd, cf*cf); +#endif + + return; +} + +int main (void) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/vect/pr37027.c b/gcc/testsuite/gcc.dg/vect/pr37027.c new file mode 100644 index 00000000000..dcfed348d11 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr37027.c @@ -0,0 +1,37 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target vect_int } */ + +#include + +struct mystr +{ + int f1; + int f2; +}; + +struct mystr a[16]; +struct mystr b[16]; +int res1, res2; + + +void +foo (void) +{ + int i; + int sum1; + int sum2; + + for (i = 0; i < 16; i++) + { + sum1 += a[i].f1 + b[i].f1; + sum2 += a[i].f2 + b[i].f2; + } + + res1 = sum1; + res2 = sum2; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_int_add } } } */ +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { xfail vect_no_int_add } } } */ +/* { dg-final { cleanup-tree-dump "vect" } } */ + diff --git a/gcc/testsuite/gcc.dg/vect/pr43842.c b/gcc/testsuite/gcc.dg/vect/pr43842.c new file mode 100644 index 00000000000..593404ffbcb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr43842.c @@ -0,0 +1,55 @@ +/* { dg-do compile } */ + +typedef char int8_t; +typedef short int int16_t; +typedef int int32_t; +typedef unsigned char uint8_t; +typedef unsigned short int uint16_t; +typedef unsigned int uint32_t; + +static int16_t +safe_rshift_func_int16_t_s_u (int16_t left, unsigned int right) +{ + return left || right >= 1 * 8 ? left : left >> right; +} + +static int8_t +safe_rshift_func_int8_t_s_u (int8_t left, unsigned int right) +{ + return left || right >= 1 * 8 ? left : left >> right; +} + + +static uint32_t +safe_add_func_uint32_t_u_u (uint32_t ui1, uint16_t ui2) +{ + return ui1 + ui2; +} + +int16_t g_4; +int8_t g_4_8; +uint32_t g_9[1]; +uint32_t g_9_8[2]; +int161 (void) +{ + int32_t l_2; + + for (l_2 = -25; l_2; l_2 = safe_add_func_uint32_t_u_u (l_2, 1)) + g_9[0] ^= safe_rshift_func_int16_t_s_u (g_4, 1); +} + +int81 (void) +{ + int32_t l_2; + + for (l_2 = -25; l_2; l_2 = safe_add_func_uint32_t_u_u (l_2, 1)) + { + g_9[0] ^= safe_rshift_func_int8_t_s_u (g_4_8, 1); + g_9[1] ^= safe_rshift_func_int8_t_s_u (g_4_8, 1); + } + + return 0; +} + +/* { dg-final { cleanup-tree-dump "vect" } } */ + diff --git a/gcc/testsuite/gcc.dg/vect/slp-reduc-1.c b/gcc/testsuite/gcc.dg/vect/slp-reduc-1.c new file mode 100644 index 00000000000..95faba8e9d4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/slp-reduc-1.c @@ -0,0 +1,49 @@ +/* { dg-require-effective-target vect_int } */ + +#include +#include +#include "tree-vect.h" + +#define N 16 + +unsigned int ub[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; +unsigned int uc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + +/* Vectorization of reduction using loop-aware SLP. */ + +__attribute__ ((noinline)) +int main1 (int n, int res0, int res1, int res2, int res3) +{ + int i; + unsigned int udiff0 = 5, udiff1 = 10, udiff2 = 20, udiff3 = 30; + + for (i = 0; i < n; i++) { + udiff3 += (ub[4*i + 3] - uc[4*i + 3]); + udiff2 += (ub[4*i + 2] - uc[4*i + 2]); + udiff1 += (ub[4*i + 1] - uc[4*i + 1]); + udiff0 += (ub[4*i] - uc[4*i]); + } + + /* Check results: */ + if (udiff0 != res0 + || udiff1 != res1 + || udiff2 != res2 + || udiff3 != res3) + abort (); + + return 0; +} + +int main (void) +{ + check_vect (); + + main1 (N/4, 53, 66, 84, 102); + main1 (N/4 - 1, 29, 40, 56, 72); + return 0; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_int_add } } } */ +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { xfail vect_no_int_add } } } */ +/* { dg-final { cleanup-tree-dump "vect" } } */ + diff --git a/gcc/testsuite/gcc.dg/vect/slp-reduc-2.c b/gcc/testsuite/gcc.dg/vect/slp-reduc-2.c new file mode 100644 index 00000000000..cb59c8c07ea --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/slp-reduc-2.c @@ -0,0 +1,44 @@ +/* { dg-require-effective-target vect_int } */ + +#include +#include +#include "tree-vect.h" + +#define N 16 + +unsigned int ub[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}; +unsigned int uc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + +/* Vectorization of reduction using loop-aware SLP (with unrolling). */ + +__attribute__ ((noinline)) +int main1 (int n, int res0, int res1, int res2, int res3) +{ + int i; + unsigned int udiff0 = 5, udiff1 = 10; + + for (i = 0; i < n; i++) { + udiff1 += (ub[2*i + 1] - uc[2*i + 1]); + udiff0 += (ub[2*i] - uc[2*i]); + } + + /* Check results: */ + if (udiff0 != res0 + || udiff1 != res1) + abort (); + + return 0; +} + +int main (void) +{ + check_vect (); + + main1 (N/2, 117, 138, 84, 102); + return 0; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_int_add } } } */ +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { xfail vect_no_int_add } } } */ +/* { dg-final { cleanup-tree-dump "vect" } } */ + diff --git a/gcc/testsuite/gcc.dg/vect/slp-reduc-3.c b/gcc/testsuite/gcc.dg/vect/slp-reduc-3.c new file mode 100644 index 00000000000..3220d3912ba --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/slp-reduc-3.c @@ -0,0 +1,62 @@ +/* { dg-require-effective-target vect_int } */ + +#include +#include "tree-vect.h" + +#define N 64 + +#define DOT1 21834 +#define DOT2 21876 + +unsigned short X[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))); +unsigned short Y[N] __attribute__ ((__aligned__(__BIGGEST_ALIGNMENT__))); + +/* short->short->int dot product. + Not detected as a dot-product pattern. + Requires support for non-widneing multiplication and widening-summation. + Vectorized with loop-aware SLP. */ +__attribute__ ((noinline)) unsigned int +foo1(int len, int *result1, int *result2) +{ + int i; + unsigned int res1 = 10, res2 = 20; + unsigned short prod; + + for (i=0; i +#include +#include "tree-vect.h" + +#define N 128 + +unsigned int uc[N]; + +/* Vectorization of reduction using loop-aware SLP. */ + +__attribute__ ((noinline)) +int main1 (int n, int res0, int res1, int res2, int res3, int res4, int res5, int res6, int res7) +{ + int i; + unsigned int max0 = 5, max1 = 10, max2 = 20, max3 = 30, max4 = 2, max5 = 13, max6 = 7, max7 = 313; + + for (i = 0; i < n; i++) { + max2 = max2 < uc[8*i+2] ? uc[8*i+2] : max2; + max3 = max3 < uc[8*i+3] ? uc[8*i+3] : max3; + max1 = max1 < uc[8*i+1] ? uc[8*i+1] : max1; + max7 = max7 < uc[8*i+7] ? uc[8*i+7] : max7; + max6 = max6 < uc[8*i+6] ? uc[8*i+6] : max6; + max0 = max0 < uc[8*i] ? uc[8*i] : max0; + max4 = max4 < uc[8*i+4] ? uc[8*i+4] : max4; + max5 = max5 < uc[8*i+5] ? uc[8*i+5] : max5; + } + + /* Check results: */ + if (max0 != res0 + || max1 != res1 + || max2 != res2 + || max3 != res3 + || max4 != res4 + || max5 != res5 + || max6 != res6 + || max7 != res7) + abort (); + + return 0; +} + +int main (void) +{ + int i; + + check_vect (); + + for (i = 0; i < N; i++) + uc[i] = i+3; + + main1 (N/8, 123, 124, 125, 126, 127, 128, 129, 313); + return 0; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_no_int_max } } } */ +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { xfail vect_no_int_max } } } */ +/* { dg-final { cleanup-tree-dump "vect" } } */ + diff --git a/gcc/testsuite/gcc.dg/vect/slp-reduc-5.c b/gcc/testsuite/gcc.dg/vect/slp-reduc-5.c new file mode 100644 index 00000000000..0974b6642d8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/slp-reduc-5.c @@ -0,0 +1,49 @@ +/* { dg-require-effective-target vect_int } */ + +#include +#include +#include "tree-vect.h" + +#define N 128 + +int c[N]; + +/* Vectorization of reduction using loop-aware SLP. */ + +__attribute__ ((noinline)) +int main1 (int n, int res0, int res1) +{ + int i; + int max0 = -100, max1 = -313; + + for (i = 0; i < n; i++) { + max1 = max1 < c[2*i+1] ? c[2*i+1] : max1; + max0 = max0 < c[2*i] ? c[2*i] : max0; + } + + /* Check results: */ + if (max0 != res0 + || max1 != res1) + abort (); + + return 0; +} + +int main (void) +{ + int i; + + check_vect (); + + for (i = 0; i < N; i++) + c[i] = (i+3) * -1; + + c[0] = c[1] = -100; + main1 (N/2, -5, -6); + return 0; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { xfail vect_no_int_max } } } */ +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 1 "vect" { xfail vect_no_int_max } } } */ +/* { dg-final { cleanup-tree-dump "vect" } } */ + diff --git a/gcc/testsuite/gcc.dg/vect/slp-reduc-6.c b/gcc/testsuite/gcc.dg/vect/slp-reduc-6.c new file mode 100644 index 00000000000..c69251a76e2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/slp-reduc-6.c @@ -0,0 +1,50 @@ +/* { dg-require-effective-target vect_int } */ + +#include +#include +#include "tree-vect.h" + +#define N 128 + +int a[N], b[N]; + +/* Vectorization of reduction. Loop-aware SLP is not possible, because of + different arrays. */ + +__attribute__ ((noinline)) +int main1 (int n, int res0, int res1) +{ + int i; + int sum0 = 0, sum1 = 0; + + for (i = 0; i < n; i++) { + sum1 += a[2*i]; + sum0 += b[2*i]; + } + + /* Check results: */ + if (sum0 != res0 + || sum1 != res1) + abort (); + + return 0; +} + +int main (void) +{ + int i; + + check_vect (); + + for (i = 0; i < N; i++) + a[i] = b[i] = i; + + main1 (N/2, 4032, 4032); + return 0; +} + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { xfail vect_no_int_add } } } */ +/* { dg-final { scan-tree-dump-times "vectorizing stmts using SLP" 0 "vect" } } */ +/* { dg-final { scan-tree-dump-times "different interleaving chains in one node" 1 "vect" { target { ! vect_no_int_add } } } } */ +/* { dg-final { cleanup-tree-dump "vect" } } */ + diff --git a/gcc/testsuite/gcc.target/arm/wmul-1.c b/gcc/testsuite/gcc.target/arm/wmul-1.c new file mode 100644 index 00000000000..df85e7cb285 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/wmul-1.c @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv6t2" } */ + +int mac(const short *a, const short *b, int sqr, int *sum) +{ + int i; + int dotp = *sum; + + for (i = 0; i < 150; i++) { + dotp += b[i] * a[i]; + sqr += b[i] * b[i]; + } + + *sum = dotp; + return sqr; +} + +/* { dg-final { scan-assembler-times "smulbb" 2 } } */ diff --git a/gcc/testsuite/gcc.target/arm/wmul-2.c b/gcc/testsuite/gcc.target/arm/wmul-2.c new file mode 100644 index 00000000000..0c092f10115 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/wmul-2.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv6t2" } */ + +void vec_mpy(int y[], const short x[], short scaler) +{ + int i; + + for (i = 0; i < 150; i++) + y[i] += ((scaler * x[i]) >> 31); +} + +/* { dg-final { scan-assembler-times "smulbb" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bfin/wmul-1.c b/gcc/testsuite/gcc.target/bfin/wmul-1.c new file mode 100644 index 00000000000..f17fc199e8c --- /dev/null +++ b/gcc/testsuite/gcc.target/bfin/wmul-1.c @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +int mac(const short *a, const short *b, int sqr, int *sum) +{ + int i; + int dotp = *sum; + + for (i = 0; i < 150; i++) { + dotp += b[i] * a[i]; + sqr += b[i] * b[i]; + } + + *sum = dotp; + return sqr; +} + +/* { dg-final { scan-assembler-times "\\(IS\\)" 2 } } */ diff --git a/gcc/testsuite/gcc.target/bfin/wmul-2.c b/gcc/testsuite/gcc.target/bfin/wmul-2.c new file mode 100644 index 00000000000..2f2d2527e69 --- /dev/null +++ b/gcc/testsuite/gcc.target/bfin/wmul-2.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +void vec_mpy(int y[], const short x[], short scaler) +{ + int i; + + for (i = 0; i < 150; i++) + y[i] += ((scaler * x[i]) >> 31); +} + +/* { dg-final { scan-assembler-times "\\(IS\\)" 1 } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr43662.c b/gcc/testsuite/gcc.target/i386/pr43662.c new file mode 100644 index 00000000000..246c8aafa6e --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr43662.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target lp64 } */ +/* { dg-options "-O2" } */ + +void __attribute__ ((ms_abi)) foo (void) +{ +} + +typedef struct _IAVIStreamImpl +{ + int sInfo; + int has; +} IAVIStreamImpl; + +extern int __attribute__ ((ms_abi)) aso (void *); +extern int sre (void *); + +int AVIFILE_OpenCompressor (IAVIStreamImpl *This) +{ + if (This->has != 0) + aso (&This->has); + sre (&This->sInfo); + return 0; +} diff --git a/gcc/testsuite/gcc.target/i386/pr43766.c b/gcc/testsuite/gcc.target/i386/pr43766.c new file mode 100644 index 00000000000..701be6ef6f8 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr43766.c @@ -0,0 +1,10 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +/* { dg-options "-O2 -msse -mregparm=3" { target ilp32 } } */ + +void p (int *a, int i) +{ + __builtin_prefetch (&a[i]); +} + +/* { dg-final { scan-assembler-not "lea" } } */ diff --git a/gcc/testsuite/gcc.target/i386/wmul-1.c b/gcc/testsuite/gcc.target/i386/wmul-1.c new file mode 100644 index 00000000000..3497f71ce54 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/wmul-1.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +/* { dg-require-effective-target ilp32 } */ + +long long mac(const int *a, const int *b, long long sqr, long long *sum) +{ + int i; + long long dotp = *sum; + + for (i = 0; i < 150; i++) { + dotp += (long long)b[i] * a[i]; + sqr += (long long)b[i] * b[i]; + } + + *sum = dotp; + return sqr; +} + +/* { dg-final { scan-assembler-times "imull" 2 } } */ diff --git a/gcc/testsuite/gcc.target/i386/wmul-2.c b/gcc/testsuite/gcc.target/i386/wmul-2.c new file mode 100644 index 00000000000..51de26960de --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/wmul-2.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +/* { dg-require-effective-target ilp32 } */ + +void vec_mpy(int y[], const int x[], int scaler) +{ + int i; + + for (i = 0; i < 150; i++) + y[i] += (((long long)scaler * x[i]) >> 31); +} + +/* { dg-final { scan-assembler-times "imull" 1 } } */ diff --git a/gcc/testsuite/gfortran.dg/abstract_type_6.f03 b/gcc/testsuite/gfortran.dg/abstract_type_6.f03 new file mode 100644 index 00000000000..bc8e5437ad5 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/abstract_type_6.f03 @@ -0,0 +1,53 @@ +! { dg-do "compile" } +! Test the fix for PR43266, in which an ICE followed correct error messages. +! +! Contributed by Tobias Burnus +! Reported in http://groups.google.ca/group/comp.lang.fortran/browse_thread/thread/f5ec99089ea72b79 +! +!---------------- +! library code + +module m +TYPE, ABSTRACT :: top +CONTAINS + PROCEDURE(xxx), DEFERRED :: proc_a ! { dg-error "must be a module procedure" } + ! some useful default behaviour + PROCEDURE :: proc_c => top_c ! { dg-error "must be a module procedure" } +END TYPE top + +! Concrete middle class with useful behaviour +TYPE, EXTENDS(top) :: middle +CONTAINS + ! do nothing, empty proc just to make middle concrete + PROCEDURE :: proc_a => dummy_middle_a ! { dg-error "must be a module procedure" } + ! some useful default behaviour + PROCEDURE :: proc_b => middle_b ! { dg-error "must be a module procedure" } +END TYPE middle + +!---------------- +! client code + +TYPE, EXTENDS(middle) :: bottom +CONTAINS + ! useful proc to satisfy deferred procedure in top. Because we've + ! extended middle we wouldn't get told off if we forgot this. + PROCEDURE :: proc_a => bottom_a + ! calls middle%proc_b and then provides extra behaviour + PROCEDURE :: proc_b => bottom_b + ! calls top_c and then provides extra behaviour + PROCEDURE :: proc_c => bottom_c +END TYPE bottom +contains +SUBROUTINE bottom_b(obj) + CLASS(Bottom) :: obj + CALL obj%middle%proc_b ! { dg-error "should be a SUBROUTINE" } + ! other stuff +END SUBROUTINE bottom_b + +SUBROUTINE bottom_c(obj) + CLASS(Bottom) :: obj + CALL top_c(obj) + ! other stuff +END SUBROUTINE bottom_c +end module +! { dg-final { cleanup-modules "m" } } diff --git a/gcc/testsuite/gfortran.dg/assign_10.f90 b/gcc/testsuite/gfortran.dg/assign_10.f90 index afe09d52c57..e52302556fe 100644 --- a/gcc/testsuite/gfortran.dg/assign_10.f90 +++ b/gcc/testsuite/gfortran.dg/assign_10.f90 @@ -19,10 +19,10 @@ if (any(p8 .ne. q8)) call abort () end ! Whichever is the default length for array indices will yield -! parm 9 times, because a temporary is not necessary. The other -! cases will all yield a temporary, so that atmp appears 27 times. +! parm 18 times, because a temporary is not necessary. The other +! cases will all yield a temporary, so that atmp appears 18 times. ! Note that it is the kind conversion that generates the temp. ! -! { dg-final { scan-tree-dump-times "parm" 9 "original" } } -! { dg-final { scan-tree-dump-times "atmp" 27 "original" } } +! { dg-final { scan-tree-dump-times "parm" 18 "original" } } +! { dg-final { scan-tree-dump-times "atmp" 18 "original" } } ! { dg-final { cleanup-tree-dump "original" } } diff --git a/gcc/testsuite/gfortran.dg/bounds_check_fail_3.f90 b/gcc/testsuite/gfortran.dg/bounds_check_fail_3.f90 index 0826b7d5efc..ce4d0368d57 100644 --- a/gcc/testsuite/gfortran.dg/bounds_check_fail_3.f90 +++ b/gcc/testsuite/gfortran.dg/bounds_check_fail_3.f90 @@ -9,4 +9,4 @@ if (any(x /= (/ 2, 2, 3, 4, 5, 6, 6, 8, 9, 10 /))) call abort() x(8:1:m) = x(5:2:n) end -! { dg-output "line 10 .* bound mismatch, .* dimension 1 .* array \'x\' \\\(3/2\\\)" } +! { dg-output "line 10 .* bound mismatch .* dimension 1 .* array \'x\' \\\(3/2\\\)" } diff --git a/gcc/testsuite/gfortran.dg/bounds_check_fail_4.f90 b/gcc/testsuite/gfortran.dg/bounds_check_fail_4.f90 index dee3ca8d66e..718d0058e49 100644 --- a/gcc/testsuite/gfortran.dg/bounds_check_fail_4.f90 +++ b/gcc/testsuite/gfortran.dg/bounds_check_fail_4.f90 @@ -9,4 +9,4 @@ if (any(x /= (/ 5, 2, 3, 6, 5, 6, 7, 8, 9, 10 /))) call abort() x(8:1:m) = x(1:3) + x(5:2:n) end -! { dg-output "line 10 .* bound mismatch, .* dimension 1 .* array \'x\' \\\(2/3\\\)" } +! { dg-output "line 10 .* bound mismatch .* dimension 1 .* array \'x\' \\\(2/3\\\)" } diff --git a/gcc/testsuite/gfortran.dg/gomp/pr43337.f90 b/gcc/testsuite/gfortran.dg/gomp/pr43337.f90 new file mode 100644 index 00000000000..f07ccb441be --- /dev/null +++ b/gcc/testsuite/gfortran.dg/gomp/pr43337.f90 @@ -0,0 +1,30 @@ +! PR middle-end/43337 +! { dg-do compile } +! { dg-options "-fopenmp -O2 -g" } + +subroutine pr43337 + integer :: a, b(10) + call foo (b) + call bar (b) +contains + subroutine foo (b) + integer :: b(10) +!$omp parallel if (.false.) +!$omp task if (.false.) shared(b) + do a = 1, 10 + b(a) = 1 + end do +!$omp end task +!$omp end parallel + end subroutine foo + subroutine bar (b) + integer :: b(10) +!$omp parallel if (.false.) +!$omp parallel if (.false.) + do a = 1, 10 + b(a) = 1 + end do +!$omp end parallel +!$omp end parallel + end subroutine bar +end subroutine pr43337 diff --git a/gcc/testsuite/gfortran.dg/gomp/pr43836.f90 b/gcc/testsuite/gfortran.dg/gomp/pr43836.f90 new file mode 100644 index 00000000000..cf86523f52b --- /dev/null +++ b/gcc/testsuite/gfortran.dg/gomp/pr43836.f90 @@ -0,0 +1,10 @@ +! PR fortran/43836 +! { dg-do compile } +! { dg-options "-fopenmp -fexceptions -O2" } +subroutine foo +!$omp single +!$omp parallel + call bar +!$omp end parallel +!$omp end single +end subroutine foo diff --git a/gcc/testsuite/gfortran.dg/gomp/sharing-2.f90 b/gcc/testsuite/gfortran.dg/gomp/sharing-2.f90 index aede06c9c0f..b7d7e072975 100644 --- a/gcc/testsuite/gfortran.dg/gomp/sharing-2.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/sharing-2.f90 @@ -28,10 +28,10 @@ end do !$omp end single !$omp end parallel -!$omp parallel default (none) shared (a) - i = 1 - j = 1 - k = 1 +!$omp parallel default (none) shared (a) ! { dg-error "enclosing parallel" } + i = 1 ! { dg-error "not specified in" } + j = 1 ! { dg-error "not specified in" } + k = 1 ! { dg-error "not specified in" } !$omp parallel default (none) shared (a) i = 1 j = 1 @@ -68,8 +68,8 @@ a(i, 1) = i + 1 end do !$omp end parallel -!$omp parallel default (none) shared (a) - i = 1 +!$omp parallel default (none) shared (a) ! { dg-error "enclosing parallel" } + i = 1 ! { dg-error "not specified in" } !$omp parallel default (none) shared (a, i) i = 2 !$omp parallel default (none) shared (a) diff --git a/gcc/testsuite/gfortran.dg/pr43796.f90 b/gcc/testsuite/gfortran.dg/pr43796.f90 new file mode 100644 index 00000000000..2e98d7ca804 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr43796.f90 @@ -0,0 +1,51 @@ +! { dg-do compile } +! { dg-options "-O2 -fcheck=bounds" } + + FUNCTION F06FKFN(N,W,INCW,X,INCX) + IMPLICIT NONE + INTEGER, PARAMETER :: WP = KIND(0.0D0) + REAL (KIND=WP) :: F06FKFN + REAL (KIND=WP), PARAMETER :: ONE = 1.0E+0_WP + REAL (KIND=WP), PARAMETER :: ZERO = 0.0E+0_WP + INTEGER, INTENT (IN) :: INCW, INCX, N + REAL (KIND=WP), INTENT (IN) :: W(*), X(*) + REAL (KIND=WP) :: ABSYI, NORM, SCALE, SSQ + INTEGER :: I, IW, IX + REAL (KIND=WP), EXTERNAL :: F06BMFN + INTRINSIC ABS, SQRT + IF (N<1) THEN + NORM = ZERO + ELSE IF (N==1) THEN + NORM = SQRT(W(1))*ABS(X(1)) + ELSE + IF (INCW>0) THEN + IW = 1 + ELSE + IW = 1 - (N-1)*INCW + END IF + IF (INCX>0) THEN + IX = 1 + ELSE + IX = 1 - (N-1)*INCX + END IF + SCALE = ZERO + SSQ = ONE + DO I = 1, N + IF ((W(IW)/=ZERO) .AND. (X(IX)/=ZERO)) THEN + ABSYI = SQRT(W(IW))*ABS(X(IX)) + IF (SCALE +! +function char1 (s) result(res) + character, dimension(:), intent(in) :: s + character(len=size(s)) :: res + do i = 1, size(s) + res(i:i) = s(i) + end do +end function char1 + +module m_string + + procedure(string_to_char) :: char1 ! segfault + procedure(string_to_char), pointer :: char2 ! segfault + type t_string + procedure(string_to_char), pointer, nopass :: char3 ! segfault + end type t_string + +contains + + function string_to_char (s) result(res) + character, dimension(:), intent(in) :: s + character(len=size(s)) :: res + do i = 1, size(s) + res(i:i) = s(i) + end do + end function string_to_char + +end module m_string + + use m_string + type(t_string) :: t + print *, string_to_char (["a","b","c"]) + char2 => string_to_char + print *, char2 (["d","e","f"]) + t%char3 => string_to_char + print *, t%char3 (["g","h","i"]) + print *, char1 (["j","k","l"]) +end +! { dg-final { cleanup-tree-dump "m_string" } } diff --git a/gcc/testsuite/gfortran.dg/reassoc_6.f b/gcc/testsuite/gfortran.dg/reassoc_6.f new file mode 100644 index 00000000000..cbc36f5675b --- /dev/null +++ b/gcc/testsuite/gfortran.dg/reassoc_6.f @@ -0,0 +1,20 @@ +! { dg-do compile } +! { dg-options "-O2 -fdump-tree-optimized" } + + subroutine test(nb,nx,r2) + implicit none + integer nb,nx,i,l + real*8 r2(nb,nx) + + + do i=1,nx + do l=1,nb + r2(l,i)=0.0d0 + enddo + enddo + + return + end +! Verify that offset of the first element is simplified +! { dg-final { scan-tree-dump-not "~" "optimized" } } +! { dg-final { cleanup-tree-dump "optimized" } } diff --git a/gcc/testsuite/gfortran.dg/vector_subscript_6.f90 b/gcc/testsuite/gfortran.dg/vector_subscript_6.f90 new file mode 100644 index 00000000000..51613d11368 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/vector_subscript_6.f90 @@ -0,0 +1,33 @@ +! { dg-do compile } +! { dg-options "-fdump-tree-original" } + +subroutine test0(esss,Ix, e_x) + real(kind=kind(1.0d0)), dimension(:), intent(out) :: esss + real(kind=kind(1.0d0)), dimension(:), intent(in) :: Ix + integer(kind=kind(1)), dimension(:), intent(in) :: e_x + esss = Ix(e_x) +end subroutine + +subroutine test1(esss,Ix, e_x) + real(kind=kind(1.0d0)), dimension(:), intent(out) :: esss + real(kind=kind(1.0d0)), dimension(:), intent(in) :: Ix + integer(kind=4), dimension(:), intent(in) :: e_x + esss = Ix(e_x) +end subroutine + +subroutine test2(esss,Ix, e_x) + real(kind=kind(1.0d0)), dimension(:), intent(out) :: esss + real(kind=kind(1.0d0)), dimension(:), intent(in) :: Ix + integer(kind=8), dimension(:), intent(in) :: e_x + esss = Ix(e_x) +end subroutine + +subroutine test3(esss,Ix,Iyz, e_x, ii_ivec) + real(kind=kind(1.0d0)), dimension(:), intent(out) :: esss + real(kind=kind(1.0d0)), dimension(:), intent(in) :: Ix,Iyz + integer(kind=kind(1)), dimension(:), intent(in) :: e_x,ii_ivec + esss = esss + Ix(e_x) * Iyz(ii_ivec) +end subroutine + +! { dg-final { scan-tree-dump-not "malloc" "original" } } +! { dg-final { cleanup-tree-dump "original" } } diff --git a/gcc/testsuite/gnat.dg/rep_clause5.adb b/gcc/testsuite/gnat.dg/rep_clause5.adb new file mode 100644 index 00000000000..7fdf264095a --- /dev/null +++ b/gcc/testsuite/gnat.dg/rep_clause5.adb @@ -0,0 +1,39 @@ +-- { dg-do compile } +-- { dg-options "-O" } + +package body Rep_Clause5 is + + function To_LNumber(S : String) return LNumber_Type is + V : VString; + LV : Long_Type; + LN : LNumber_Type; + begin + LV := To_Long(V, 10); + LN := LNumber_Type(LV); + return LN; + end; + + procedure Merge_Numbered(LNodes : in out LNodes_Ptr) is + T1 : Token_Type; + LNO : LNumber_Type; + begin + for X in LNodes.all'Range loop + T1 := LNodes(X).Line(0); + if T1.Token /= LEX_LF then + declare + S : String := Element(T1.SID); + begin + begin + LNO := To_LNumber(S); + exception + when Bad_Number => + LNO := 0; + when Too_Large => + LNO := 0; + end; + end; + end if; + end loop; + end; + +end Rep_Clause5; diff --git a/gcc/testsuite/gnat.dg/rep_clause5.ads b/gcc/testsuite/gnat.dg/rep_clause5.ads new file mode 100644 index 00000000000..986f893ecbb --- /dev/null +++ b/gcc/testsuite/gnat.dg/rep_clause5.ads @@ -0,0 +1,12 @@ +with Rep_Clause5_Pkg; use Rep_Clause5_Pkg; + +package Rep_Clause5 is + + Bad_Number : exception; + Too_Large : exception; + + type LNumber_Type is range 0..99999; + + procedure Merge_Numbered(LNodes : in out LNodes_Ptr); + +end Rep_Clause5; diff --git a/gcc/testsuite/gnat.dg/rep_clause5_pkg.ads b/gcc/testsuite/gnat.dg/rep_clause5_pkg.ads new file mode 100644 index 00000000000..e3496c4a2b7 --- /dev/null +++ b/gcc/testsuite/gnat.dg/rep_clause5_pkg.ads @@ -0,0 +1,383 @@ +package Rep_Clause5_Pkg is + + type ID_Type is mod 65536; + type String_ID is new ID_Type; + type LNumber_Type is range 0..99999; + subtype Long_Type is Integer; + + type Func_ID is (No_Func, FUN_SGN, FUN_EXP, FUN_LOG, FUN_LOG10); + + type Token_Kind is ( + No_Token, + LEX_BINARY, + LEX_SECTION, + LEX_003, + LEX_004, + LEX_005, + LEX_006, + LEX_007, + LEX_008, + LEX_009, + LEX_LF, + LEX_011, + LEX_012, + LEX_013, + LEX_014, + LEX_015, + LEX_016, + LEX_017, + LEX_018, + LEX_019, + LEX_020, + LEX_021, + LEX_022, + LEX_023, + LEX_024, + LEX_025, + LEX_026, + LEX_027, + LEX_028, + LEX_029, + LEX_030, + LEX_031, + LEX_032, + '!', + '"', + '#', + '$', + '%', + '&', + ''', + '(', + ')', + '*', + '+', + ',', + '-', + '.', + '/', + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', + ':', + ';', + '<', + '=', + '>', + '?', + '@', + 'A', + 'B', + 'C', + 'D', + 'E', + 'F', + 'G', + 'H', + 'I', + 'J', + 'K', + 'L', + 'M', + 'N', + 'O', + 'P', + 'Q', + 'R', + 'S', + 'T', + 'U', + 'V', + 'W', + 'X', + 'Y', + 'Z', + '[', + '\', + ']', + '^', + '_', + '`', + 'a', + 'b', + 'c', + 'd', + 'e', + 'f', + 'g', + 'h', + 'i', + 'j', + 'k', + 'l', + 'm', + 'n', + 'o', + LEX_SFUN3, + LEX_SFUN2, + LEX_SFUN1, + LEX_SFUNN, + LEX_FUN3, + LEX_FUN2, + LEX_FUN1, + LEX_FUNN, + 'x', + 'y', + 'z', + '{', + '|', + '}', + '~', + LEX_CRTA, + LEX_ISNULL, + LEX_USING, + LEX_HANDLE, + LEX_CALLX, + LEX_COMPLEX, + LEX_FIXED, + LEX_ENV, + LEX_SPARSE, + LEX_SUBROUTINE, + LEX_CALL, + LEX_BOX, + LEX_VLINE, + LEX_HLINE, + LEX_MAXLENGTH, + LEX_DLENGTH, + LEX_INPUT, + LEX_INITIALIZE, + LEX_OUTPUT, + LEX_UNLINK, + LEX_SEEK, + LEX_EXIT, + LEX_NOT, + LEX_COMMON, + LEX_CHAIN, + LEX_DEF, + LEX_ARITY, + LEX_RESUME, + LEX_PIC_S, + LEX_BG, + LEX_FG, + LEX_PC, + LEX_CRT, + LEX_ENUM, + LEX_DECLARE, + LEX_CURSOR, + LEX_DROP, + LEX_CURRENT, + LEX_ISOLATION, + LEX_SET, + LEX_TRANSACTION, + LEX_COMMIT, + LEX_ABORT, + LEX_BEGIN, + LEX_PREVIOUS, + LEX_LAST, + LEX_FIRST, + LEX_KEY, + LEX_START, + LEX_REWRITE, + LEX_INDEX, + LEX_SECONDARY, + LEX_PRIMARY, + LEX_COLUMN, + LEX_TEMP, + LEX_TABLE, + LEX_CREATE, + LEX_HASH, + LEX_BTREE, + LEX_UPDATE, + LEX_ERROR, + LEX_ACCEPT, + LEX_AVG, + LEX_MAX, + LEX_MIN, + LEX_FIELD, + LEX_RESTORE, + LEX_END, + LEX_STEP, + LEX_NEXT, + LEX_FOR, + LEX_RETURN, + LEX_GOSUB, + LEX_RANGE, + LEX_EXPON, + LEX_XOR, + LEX_OR, + LEX_AND, + LEX_SHIFTR, + LEX_GE, + LEX_NE, + LEX_SHIFTL, + LEX_LE, + LEX_VARYING, + LEX_LENGTH, + LEX_PRINT, + LEX_IF, + LEX_GOTO, + LEX_ON, + LEX_THEN, + LEX_DELETE, + LEX_TO, + LEX_SEQUENCE, + LEX_NONUNIQUE, + LEX_UNIQUE, + LEX_FILE, + LEX_CLOSE, + LEX_OPEN, + LEX_DATABASE, + LEX_RECORD, + LEX_DATA, + LEX_WRITE, + LEX_READ, + LEX_STOP, + LEX_LET, + LEX_MOD, + LEX_LONG, + LEX_DIM, + LEX_SHORT, + LEX_REM, + LEX_SHELL, + LEX_TOKEN, + LEX_FLOAT, + LEX_SIDENT, + LEX_INLREM, + LEX_ENDLIT, + LEX_STRLIT, + LEX_IDENT, + LEX_LNUMBER, + LEX_HEX, + LEX_NUMBER, + LEX_EOF, + LEX_QUIT, + LEX_LIST, + LEX_REMOVE, + LEX_RENUMBER, + LEX_CONTINUE, + LEX_RUN, + LEX_MERGE, + LEX_ENTER, + LEX_NEW, + LEX_RESET, + LEX_SYMTAB, + LEX_CLS, + LEX_EDIT, + LEX_SAVE, + LEX_RESAVE, + LEX_LOAD, + LEX_NAME, + LEX_LISTP, + LEX_SHOW, + LEX_STACK, + LEX_STATUS, + LEX_CACHE, + LEX_INSPECT, + LEX_STOW, + LEX_PKGRUN, + LEX_POP, + LEX_CHECK, + LEX_INSERT, + LEX_INTO, + LEX_VALUES, + LEX_NULL, + LEX_WHERE, + LEX_FROM, + LEX_EXEC, + LEX_SELECT, + LEX_AS, + LEX_ALL, + LEX_BY, + LEX_CROSS, + LEX_DESC, + LEX_FULL, + LEX_GROUP, + LEX_INNER, + LEX_JOIN, + LEX_LEFT, + LEX_LIMIT, + LEX_NATURAL, + LEX_OFFSET, + LEX_ORDER, + LEX_OUTER, + LEX_RIGHT, + LEX_FETCH, + LEX_DISTINCT, + LEX_DEFAULT, + LEX_RETURNING, + LEX_LEVEL, + LEX_COMMITTED, + LEX_SERIALIZABLE, + LEX_ONLY, + LEX_HOLD, + LEX_FORWARD, + LEX_WITH, + LEX_PRIOR, + LEX_RELATIVE, + LEX_BACKWARD, + LEX_OF, + LEX_SCROLL, + LEX_NOWAIT, + LEX_HAVING, + LEX_END_TOKENS + ); + + type Aux_Kind is (No_Aux, SID_Aux, FID_Aux, LNO_Aux); + + type Token_Type(Aux : Aux_Kind := No_Aux) is + record + Token : Token_Kind := No_Token; + case Aux is + when SID_Aux => + SID : String_ID; + when FID_Aux => + FID : Func_ID; + when LNO_Aux => + LNO : LNumber_Type; + when No_Aux => + null; + end case; + end record; + + for Token_Type use + record + Aux at 0 range 0..2; + Token at 0 range 3..12; + SID at 0 range 16..31; + FID at 0 range 16..31; + LNO at 0 range 13..31; + end record; + + type Tokens_Index is range 0..999999; + type Token_Array is array(Tokens_Index range <>) of Token_Type; + type Token_Line is access all Token_Array; + + type Line_Node is + record + Line : Token_Line; + LNO : LNumber_Type := 0; + Numbered : Boolean := False; + end record; + + type Nodes_Index is range 0..999999; + type LNodes_Array is array(Nodes_Index range <>) of Line_Node; + type LNodes_Ptr is access all LNodes_Array; + + type VString is + record + Max_Length : Natural := 0; + Fixed : Boolean := False; + end record; + + function To_Long(Object : VString; Radix : Natural) return Long_Type; + + function Element (V : String_ID) return String; + +end Rep_Clause5_Pkg; diff --git a/gcc/testsuite/gnat.dg/sizetype.adb b/gcc/testsuite/gnat.dg/sizetype1.adb similarity index 91% rename from gcc/testsuite/gnat.dg/sizetype.adb rename to gcc/testsuite/gnat.dg/sizetype1.adb index acc2d6560bd..e5d12c61e09 100644 --- a/gcc/testsuite/gnat.dg/sizetype.adb +++ b/gcc/testsuite/gnat.dg/sizetype1.adb @@ -2,7 +2,7 @@ with Interfaces.C; use Interfaces.C; -procedure Sizetype is +procedure Sizetype1 is TC_String : String(1..8) := "abcdefgh"; TC_No_nul : constant char_array := To_C(TC_String, False); diff --git a/gcc/testsuite/gnat.dg/sizetype2.adb b/gcc/testsuite/gnat.dg/sizetype2.adb new file mode 100644 index 00000000000..4593936c826 --- /dev/null +++ b/gcc/testsuite/gnat.dg/sizetype2.adb @@ -0,0 +1,27 @@ +-- { dg-do run } + +procedure Sizetype2 is + + function Ident_Int (X : Integer) return Integer is + begin + return X; + end; + + type A is array (Integer range <>) of Boolean; + subtype T1 is A (Ident_Int (- 6) .. Ident_Int (Integer'Last - 4)); + subtype T2 is A (- 6 .. Ident_Int (Integer'Last - 4)); + subtype T3 is A (Ident_Int (- 6) .. Integer'Last - 4); + +begin + if T1'Size /= 17179869200 then + raise Program_Error; + end if; + + if T2'Size /= 17179869200 then + raise Program_Error; + end if; + + if T3'Size /= 17179869200 then + raise Program_Error; + end if; +end; diff --git a/gcc/testsuite/lib/prune.exp b/gcc/testsuite/lib/prune.exp index ef647d533ed..160f651b6e7 100644 --- a/gcc/testsuite/lib/prune.exp +++ b/gcc/testsuite/lib/prune.exp @@ -23,6 +23,7 @@ proc prune_gcc_output { text } { regsub -all "(^|\n)(\[^\n\]*: )?In ((static member |lambda )?function|member|method|(copy )?constructor|destructor|instantiation|program|subroutine|block-data)\[^\n\]*" $text "" text regsub -all "(^|\n)\[^\n\]*(: )?At (top level|global scope):\[^\n\]*" $text "" text regsub -all "(^|\n)\[^\n\]*: instantiated from \[^\n\]*" $text "" text + regsub -all "(^|\n)\[^\n\]*: . skipping \[0-9\]* instantiation contexts \[^\n\]*" $text "" text regsub -all "(^|\n) inlined from \[^\n\]*" $text "" text regsub -all "(^|\n)collect2: ld returned \[^\n\]*" $text "" text regsub -all "(^|\n)collect: re(compiling|linking)\[^\n\]*" $text "" text diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index 126ae380fe7..e91c0331516 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -2105,6 +2105,25 @@ proc check_effective_target_vect_perm { } { return $et_vect_perm_saved } +# Return 1 if the target plus current options supports a vector +# widening summation of *short* args into *int* result, 0 otherwise. +# +# This won't change for different subtargets so cache the result. + +proc check_effective_target_vect_widen_sum_hi_to_si_pattern { } { + global et_vect_widen_sum_hi_to_si_pattern + + if [info exists et_vect_widen_sum_hi_to_si_pattern_saved] { + verbose "check_effective_target_vect_widen_sum_hi_to_si_pattern: using cached result" 2 + } else { + set et_vect_widen_sum_hi_to_si_pattern_saved 0 + if { [istarget powerpc*-*-*] } { + set et_vect_widen_sum_hi_to_si_pattern_saved 1 + } + } + verbose "check_effective_target_vect_widen_sum_hi_to_si_pattern: returning $et_vect_widen_sum_hi_to_si_pattern_saved" 2 + return $et_vect_widen_sum_hi_to_si_pattern_saved +} # Return 1 if the target plus current options supports a vector # widening summation of *short* args into *int* result, 0 otherwise. diff --git a/gcc/timevar.def b/gcc/timevar.def index 19dec149a28..63530b8e973 100644 --- a/gcc/timevar.def +++ b/gcc/timevar.def @@ -57,7 +57,6 @@ DEFTIMEVAR (TV_LTO , "lto") DEFTIMEVAR (TV_WHOPR_WPA , "whopr wpa") DEFTIMEVAR (TV_WHOPR_WPA_IO , "whopr wpa I/O") DEFTIMEVAR (TV_WHOPR_LTRANS , "whopr ltrans") -DEFTIMEVAR (TV_WHOPR_WPA_FIXUP , "whopr wpa fixup") DEFTIMEVAR (TV_WHOPR_WPA_LTRANS_EXEC , "whopr wpa->ltrans") DEFTIMEVAR (TV_IPA_REFERENCE , "ipa reference") DEFTIMEVAR (TV_IPA_PURE_CONST , "ipa pure const") diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 2a66d568b3c..03d118966fc 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -3455,8 +3455,13 @@ do_pointer_plus_expr_check: connected to the operand types. */ return verify_gimple_comparison (lhs_type, rhs1, rhs2); - case WIDEN_SUM_EXPR: case WIDEN_MULT_EXPR: + if (TREE_CODE (lhs_type) != INTEGER_TYPE) + return true; + return ((2 * TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (lhs_type)) + || (TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type))); + + case WIDEN_SUM_EXPR: case VEC_WIDEN_MULT_HI_EXPR: case VEC_WIDEN_MULT_LO_EXPR: case VEC_PACK_TRUNC_EXPR: diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c index a89d151c261..9abb2a8422e 100644 --- a/gcc/tree-data-ref.c +++ b/gcc/tree-data-ref.c @@ -2176,6 +2176,7 @@ analyze_subscript_affine_affine (tree chrec_a, unsigned nb_vars_a, nb_vars_b, dim; HOST_WIDE_INT init_a, init_b, gamma, gcd_alpha_beta; lambda_matrix A, U, S; + struct obstack scratch_obstack; if (eq_evolutions_p (chrec_a, chrec_b)) { @@ -2203,10 +2204,12 @@ analyze_subscript_affine_affine (tree chrec_a, nb_vars_a = nb_vars_in_chrec (chrec_a); nb_vars_b = nb_vars_in_chrec (chrec_b); + gcc_obstack_init (&scratch_obstack); + dim = nb_vars_a + nb_vars_b; - U = lambda_matrix_new (dim, dim); - A = lambda_matrix_new (dim, 1); - S = lambda_matrix_new (dim, 1); + U = lambda_matrix_new (dim, dim, &scratch_obstack); + A = lambda_matrix_new (dim, 1, &scratch_obstack); + S = lambda_matrix_new (dim, 1, &scratch_obstack); init_a = int_cst_value (initialize_matrix_A (A, chrec_a, 0, 1)); init_b = int_cst_value (initialize_matrix_A (A, chrec_b, nb_vars_a, -1)); @@ -2420,6 +2423,7 @@ analyze_subscript_affine_affine (tree chrec_a, } end_analyze_subs_aa: + obstack_free (&scratch_obstack, NULL); if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, " (overlaps_a = "); diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h index 678eb10cc18..eff53483116 100644 --- a/gcc/tree-data-ref.h +++ b/gcc/tree-data-ref.h @@ -584,7 +584,9 @@ bool lambda_transform_legal_p (lambda_trans_matrix, int, void lambda_collect_parameters (VEC (data_reference_p, heap) *, VEC (tree, heap) **); bool lambda_compute_access_matrices (VEC (data_reference_p, heap) *, - VEC (tree, heap) *, VEC (loop_p, heap) *); + VEC (tree, heap) *, + VEC (loop_p, heap) *, + struct obstack *); /* In tree-data-ref.c */ void split_constant_offset (tree , tree *, tree *); diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c index 5475d79254b..d5a56e5e299 100644 --- a/gcc/tree-dfa.c +++ b/gcc/tree-dfa.c @@ -193,11 +193,7 @@ renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks) tree make_rename_temp (tree type, const char *prefix) { - tree t = create_tmp_var (type, prefix); - - if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (t) = 1; + tree t = create_tmp_reg (type, prefix); if (gimple_referenced_vars (cfun)) { diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c index 384e43c770c..fbab7db9676 100644 --- a/gcc/tree-loop-distribution.c +++ b/gcc/tree-loop-distribution.c @@ -227,12 +227,9 @@ build_size_arg_loc (location_t loc, tree nb_iter, tree op, gimple_seq *stmt_list) { gimple_seq stmts; - tree x; - - x = fold_build2_loc (loc, MULT_EXPR, size_type_node, - fold_convert_loc (loc, size_type_node, nb_iter), - fold_convert_loc (loc, size_type_node, - TYPE_SIZE_UNIT (TREE_TYPE (op)))); + tree x = size_binop_loc (loc, MULT_EXPR, + fold_convert_loc (loc, sizetype, nb_iter), + TYPE_SIZE_UNIT (TREE_TYPE (op))); x = force_gimple_operand (x, &stmts, true, NULL); gimple_seq_add_seq (stmt_list, stmts); diff --git a/gcc/tree-loop-linear.c b/gcc/tree-loop-linear.c index 04731c76820..047389c6e6a 100644 --- a/gcc/tree-loop-linear.c +++ b/gcc/tree-loop-linear.c @@ -358,14 +358,15 @@ linear_transform_loops (void) goto free_and_continue; lambda_collect_parameters (datarefs, &lambda_parameters); - if (!lambda_compute_access_matrices (datarefs, lambda_parameters, nest)) + if (!lambda_compute_access_matrices (datarefs, lambda_parameters, + nest, &lambda_obstack)) goto free_and_continue; if (dump_file && (dump_flags & TDF_DETAILS)) dump_ddrs (dump_file, dependence_relations); /* Build the transformation matrix. */ - trans = lambda_trans_matrix_new (depth, depth); + trans = lambda_trans_matrix_new (depth, depth, &lambda_obstack); lambda_matrix_id (LTM_MATRIX (trans), depth); trans = try_interchange_loops (trans, depth, dependence_relations, datarefs, loop_nest); diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c index fb95088b648..a3aa6c4c384 100644 --- a/gcc/tree-nested.c +++ b/gcc/tree-nested.c @@ -1,5 +1,5 @@ /* Nested function decomposition for GIMPLE. - Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 + Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GCC. @@ -1088,7 +1088,8 @@ convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi) { bitmap_set_bit (new_suppress, DECL_UID (decl)); OMP_CLAUSE_DECL (clause) = get_nonlocal_debug_decl (info, decl); - need_chain = true; + if (OMP_CLAUSE_CODE (clause) != OMP_CLAUSE_PRIVATE) + need_chain = true; } break; diff --git a/gcc/tree-object-size.c b/gcc/tree-object-size.c index 135342d58b0..2892e84600c 100644 --- a/gcc/tree-object-size.c +++ b/gcc/tree-object-size.c @@ -1203,7 +1203,8 @@ compute_object_sizes (void) result = fold_convert (size_type_node, integer_minus_one_node); else if (object_size_type < 4) - result = size_zero_node; + result = fold_convert (size_type_node, + integer_zero_node); } } diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c index c4ac89b001a..69a0b659616 100644 --- a/gcc/tree-parloops.c +++ b/gcc/tree-parloops.c @@ -248,7 +248,7 @@ name_to_copy_elt_hash (const void *aa) in parallel). */ static bool -loop_parallel_p (struct loop *loop) +loop_parallel_p (struct loop *loop, struct obstack * parloop_obstack) { VEC (ddr_p, heap) * dependence_relations; VEC (data_reference_p, heap) *datarefs; @@ -273,7 +273,7 @@ loop_parallel_p (struct loop *loop) if (dump_file && (dump_flags & TDF_DETAILS)) dump_data_dependence_relations (dump_file, dependence_relations); - trans = lambda_trans_matrix_new (1, 1); + trans = lambda_trans_matrix_new (1, 1, parloop_obstack); LTM_MATRIX (trans)[0][0] = -1; if (lambda_transform_legal_p (trans, 1, dependence_relations)) @@ -1884,15 +1884,17 @@ parallelize_loops (void) struct tree_niter_desc niter_desc; loop_iterator li; htab_t reduction_list; + struct obstack parloop_obstack; HOST_WIDE_INT estimated; LOC loop_loc; - + /* Do not parallelize loops in the functions created by parallelization. */ if (parallelized_function_p (cfun->decl)) return false; if (cfun->has_nonlocal_label) return false; + gcc_obstack_init (&parloop_obstack); reduction_list = htab_create (10, reduction_info_hash, reduction_info_eq, free); init_stmt_vec_info_vec (); @@ -1950,7 +1952,8 @@ parallelize_loops (void) if (!try_create_reduction_list (loop, reduction_list)) continue; - if (!flag_loop_parallelize_all && !loop_parallel_p (loop)) + if (!flag_loop_parallelize_all + && !loop_parallel_p (loop, &parloop_obstack)) continue; changed = true; @@ -1975,6 +1978,7 @@ parallelize_loops (void) free_stmt_vec_info_vec (); htab_delete (reduction_list); + obstack_free (&parloop_obstack, NULL); /* Parallelization will cause new function calls to be inserted through which local variables will escape. Reset the points-to solution diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h index 019b9332b81..3d7798e4ca4 100644 --- a/gcc/tree-pass.h +++ b/gcc/tree-pass.h @@ -182,11 +182,15 @@ struct ipa_opt_pass_d /* This hook is used to serialize IPA summaries on disk. */ void (*write_summary) (struct cgraph_node_set_def *); - /* For most ipa passes, the information can only be deserialized in - one chunk. However, function bodies are read function at a time - as needed so both calls are necessary. */ + /* This hook is used to deserialize IPA summaries from disk. */ void (*read_summary) (void); - void (*function_read_summary) (struct cgraph_node *); + + /* This hook is used to serialize IPA optimization summaries on disk. */ + void (*write_optimization_summary) (struct cgraph_node_set_def *); + + /* This hook is used to deserialize IPA summaries from disk. */ + void (*read_optimization_summary) (void); + /* Hook to convert gimple stmt uids into true gimple statements. The second parameter is an array of statements indexed by their uid. */ void (*stmt_fixup) (struct cgraph_node *, gimple *); @@ -407,6 +411,7 @@ extern struct gimple_opt_pass pass_late_warn_uninitialized; extern struct gimple_opt_pass pass_cse_reciprocals; extern struct gimple_opt_pass pass_cse_sincos; extern struct gimple_opt_pass pass_optimize_bswap; +extern struct gimple_opt_pass pass_optimize_widening_mul; extern struct gimple_opt_pass pass_warn_function_return; extern struct gimple_opt_pass pass_warn_function_noreturn; extern struct gimple_opt_pass pass_cselim; @@ -601,9 +606,9 @@ extern const char *get_current_pass_name (void); extern void print_current_pass (FILE *); extern void debug_pass (void); extern void ipa_write_summaries (void); -extern void ipa_write_summaries_of_cgraph_node_set ( - struct cgraph_node_set_def *); +extern void ipa_write_optimization_summaries (struct cgraph_node_set_def *); extern void ipa_read_summaries (void); +extern void ipa_read_optimization_summaries (void); extern void register_one_dump_file (struct opt_pass *); extern bool function_called_by_processed_nodes_p (void); extern void register_pass (struct register_pass_info *); diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c index 62708cd8523..41873cefb8c 100644 --- a/gcc/tree-predcom.c +++ b/gcc/tree-predcom.c @@ -1460,13 +1460,9 @@ static tree predcom_tmp_var (tree ref, unsigned i, bitmap tmp_vars) { tree type = TREE_TYPE (ref); - tree var = create_tmp_var (type, get_lsm_tmp_name (ref, i)); - /* We never access the components of the temporary variable in predictive commoning. */ - if (TREE_CODE (type) == COMPLEX_TYPE - || TREE_CODE (type) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (var) = 1; + tree var = create_tmp_reg (type, get_lsm_tmp_name (ref, i)); add_referenced_var (var); bitmap_set_bit (tmp_vars, DECL_UID (var)); @@ -2209,18 +2205,12 @@ reassociate_to_the_same_stmt (tree name1, tree name2) /* Insert the new statement combining NAME1 and NAME2 before S1, and combine it with the rhs of S1. */ - var = create_tmp_var (type, "predreastmp"); - if (TREE_CODE (type) == COMPLEX_TYPE - || TREE_CODE (type) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (var) = 1; + var = create_tmp_reg (type, "predreastmp"); add_referenced_var (var); new_name = make_ssa_name (var, NULL); new_stmt = gimple_build_assign_with_ops (code, new_name, name1, name2); - var = create_tmp_var (type, "predreastmp"); - if (TREE_CODE (type) == COMPLEX_TYPE - || TREE_CODE (type) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (var) = 1; + var = create_tmp_reg (type, "predreastmp"); add_referenced_var (var); tmp_name = make_ssa_name (var, NULL); diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 0a9b3df3b15..0635aa7f4a8 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -2537,10 +2537,7 @@ replace_uses_with_default_def_ssa_name (tree ssa) tree repl, decl = SSA_NAME_VAR (ssa); if (TREE_CODE (decl) == PARM_DECL) { - tree tmp = create_tmp_var (TREE_TYPE (decl), "SR"); - if (TREE_CODE (TREE_TYPE (tmp)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (tmp)) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (tmp) = 1; + tree tmp = create_tmp_reg (TREE_TYPE (decl), "SR"); get_var_ann (tmp); add_referenced_var (tmp); @@ -3733,10 +3730,7 @@ get_replaced_param_substitute (struct ipa_parm_adjustment *adj) { char *pretty_name = make_fancy_name (adj->base); - repl = create_tmp_var (TREE_TYPE (adj->base), "ISR"); - if (TREE_CODE (TREE_TYPE (repl)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (repl)) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (repl) = 1; + repl = create_tmp_reg (TREE_TYPE (adj->base), "ISR"); DECL_NAME (repl) = get_identifier (pretty_name); obstack_free (&name_obstack, pretty_name); diff --git a/gcc/tree-ssa-address.c b/gcc/tree-ssa-address.c index a2485c5efbc..f0cbdfee8c9 100644 --- a/gcc/tree-ssa-address.c +++ b/gcc/tree-ssa-address.c @@ -192,14 +192,12 @@ addr_for_mem_ref (struct mem_address *addr, addr_space_t as, struct mem_addr_template *templ; if (addr->step && !integer_onep (addr->step)) - st = immed_double_const (TREE_INT_CST_LOW (addr->step), - TREE_INT_CST_HIGH (addr->step), address_mode); + st = immed_double_int_const (tree_to_double_int (addr->step), address_mode); else st = NULL_RTX; if (addr->offset && !integer_zerop (addr->offset)) - off = immed_double_const (TREE_INT_CST_LOW (addr->offset), - TREE_INT_CST_HIGH (addr->offset), address_mode); + off = immed_double_int_const (tree_to_double_int (addr->offset), address_mode); else off = NULL_RTX; diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c index 2ca17c70dab..90ede52c4b7 100644 --- a/gcc/tree-ssa-math-opts.c +++ b/gcc/tree-ssa-math-opts.c @@ -1260,3 +1260,137 @@ struct gimple_opt_pass pass_optimize_bswap = 0 /* todo_flags_finish */ } }; + +/* Find integer multiplications where the operands are extended from + smaller types, and replace the MULT_EXPR with a WIDEN_MULT_EXPR + where appropriate. */ + +static unsigned int +execute_optimize_widening_mul (void) +{ + bool changed = false; + basic_block bb; + + FOR_EACH_BB (bb) + { + gimple_stmt_iterator gsi; + + for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi)) + { + gimple stmt = gsi_stmt (gsi); + gimple rhs1_stmt = NULL, rhs2_stmt = NULL; + tree type, type1 = NULL, type2 = NULL; + tree rhs1, rhs2, rhs1_convop = NULL, rhs2_convop = NULL; + enum tree_code rhs1_code, rhs2_code; + + if (!is_gimple_assign (stmt) + || gimple_assign_rhs_code (stmt) != MULT_EXPR) + continue; + + type = TREE_TYPE (gimple_assign_lhs (stmt)); + + if (TREE_CODE (type) != INTEGER_TYPE) + continue; + + rhs1 = gimple_assign_rhs1 (stmt); + rhs2 = gimple_assign_rhs2 (stmt); + + if (TREE_CODE (rhs1) == SSA_NAME) + { + rhs1_stmt = SSA_NAME_DEF_STMT (rhs1); + if (!is_gimple_assign (rhs1_stmt)) + continue; + rhs1_code = gimple_assign_rhs_code (rhs1_stmt); + if (!CONVERT_EXPR_CODE_P (rhs1_code)) + continue; + rhs1_convop = gimple_assign_rhs1 (rhs1_stmt); + type1 = TREE_TYPE (rhs1_convop); + if (TYPE_PRECISION (type1) * 2 != TYPE_PRECISION (type)) + continue; + } + else if (TREE_CODE (rhs1) != INTEGER_CST) + continue; + + if (TREE_CODE (rhs2) == SSA_NAME) + { + rhs2_stmt = SSA_NAME_DEF_STMT (rhs2); + if (!is_gimple_assign (rhs2_stmt)) + continue; + rhs2_code = gimple_assign_rhs_code (rhs2_stmt); + if (!CONVERT_EXPR_CODE_P (rhs2_code)) + continue; + rhs2_convop = gimple_assign_rhs1 (rhs2_stmt); + type2 = TREE_TYPE (rhs2_convop); + if (TYPE_PRECISION (type2) * 2 != TYPE_PRECISION (type)) + continue; + } + else if (TREE_CODE (rhs2) != INTEGER_CST) + continue; + + if (rhs1_stmt == NULL && rhs2_stmt == NULL) + continue; + + /* Verify that the machine can perform a widening multiply in this + mode/signedness combination, otherwise this transformation is + likely to pessimize code. */ + if ((rhs1_stmt == NULL || TYPE_UNSIGNED (type1)) + && (rhs2_stmt == NULL || TYPE_UNSIGNED (type2)) + && (optab_handler (umul_widen_optab, TYPE_MODE (type)) + ->insn_code == CODE_FOR_nothing)) + continue; + else if ((rhs1_stmt == NULL || !TYPE_UNSIGNED (type1)) + && (rhs2_stmt == NULL || !TYPE_UNSIGNED (type2)) + && (optab_handler (smul_widen_optab, TYPE_MODE (type)) + ->insn_code == CODE_FOR_nothing)) + continue; + else if (rhs1_stmt != NULL && rhs2_stmt != 0 + && (TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2)) + && (optab_handler (usmul_widen_optab, TYPE_MODE (type)) + ->insn_code == CODE_FOR_nothing)) + continue; + + if ((rhs1_stmt == NULL && !int_fits_type_p (rhs1, type2)) + || (rhs2_stmt == NULL && !int_fits_type_p (rhs2, type1))) + continue; + + if (rhs1_stmt == NULL) + gimple_assign_set_rhs1 (stmt, fold_convert (type2, rhs1)); + else + gimple_assign_set_rhs1 (stmt, rhs1_convop); + if (rhs2_stmt == NULL) + gimple_assign_set_rhs2 (stmt, fold_convert (type1, rhs2)); + else + gimple_assign_set_rhs2 (stmt, rhs2_convop); + gimple_assign_set_rhs_code (stmt, WIDEN_MULT_EXPR); + update_stmt (stmt); + changed = true; + } + } + return (changed ? TODO_dump_func | TODO_update_ssa | TODO_verify_ssa + | TODO_verify_stmts : 0); +} + +static bool +gate_optimize_widening_mul (void) +{ + return flag_expensive_optimizations && optimize; +} + +struct gimple_opt_pass pass_optimize_widening_mul = +{ + { + GIMPLE_PASS, + "widening_mul", /* name */ + gate_optimize_widening_mul, /* gate */ + execute_optimize_widening_mul, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_NONE, /* tv_id */ + PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + 0 /* todo_flags_finish */ + } +}; diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c index b4a0aea9718..33e058c2275 100644 --- a/gcc/tree-ssa-phiopt.c +++ b/gcc/tree-ssa-phiopt.c @@ -1226,11 +1226,8 @@ cond_store_replacement (basic_block middle_bb, basic_block join_bb, of the memory touched by the store, if we need to. */ if (!condstoretemp || TREE_TYPE (lhs) != TREE_TYPE (condstoretemp)) { - condstoretemp = create_tmp_var (TREE_TYPE (lhs), "cstore"); + condstoretemp = create_tmp_reg (TREE_TYPE (lhs), "cstore"); get_var_ann (condstoretemp); - if (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (lhs)) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (condstoretemp) = 1; } add_referenced_var (condstoretemp); diff --git a/gcc/tree-ssa-phiprop.c b/gcc/tree-ssa-phiprop.c index fcd1d23bac8..799bb5a1e0b 100644 --- a/gcc/tree-ssa-phiprop.c +++ b/gcc/tree-ssa-phiprop.c @@ -190,11 +190,8 @@ phiprop_insert_phi (basic_block bb, gimple phi, gimple use_stmt, { gcc_assert (TREE_CODE (old_arg) == ADDR_EXPR); old_arg = TREE_OPERAND (old_arg, 0); - new_var = create_tmp_var (TREE_TYPE (old_arg), NULL); + new_var = create_tmp_reg (TREE_TYPE (old_arg), NULL); tmp = gimple_build_assign (new_var, unshare_expr (old_arg)); - if (TREE_CODE (TREE_TYPE (old_arg)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (old_arg)) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (new_var) = 1; gcc_assert (is_gimple_reg (new_var)); add_referenced_var (new_var); new_var = make_ssa_name (new_var, tmp); diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index ae630df1b48..3a81f2c9316 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -1407,7 +1407,7 @@ get_representative_for (const pre_expr e) that we will return. */ if (!pretemp || exprtype != TREE_TYPE (pretemp)) { - pretemp = create_tmp_var (exprtype, "pretmp"); + pretemp = create_tmp_reg (exprtype, "pretmp"); get_var_ann (pretemp); } @@ -2631,31 +2631,46 @@ create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref, { case CALL_EXPR: { - tree folded, sc = currop->op1; + tree folded, sc = NULL_TREE; unsigned int nargs = 0; - tree *args = XNEWVEC (tree, VEC_length (vn_reference_op_s, - ref->operands) - 1); + tree fn, *args; + if (TREE_CODE (currop->op0) == FUNCTION_DECL) + fn = currop->op0; + else + { + pre_expr op0 = get_or_alloc_expr_for (currop->op0); + fn = find_or_generate_expression (block, op0, stmts, domstmt); + if (!fn) + return NULL_TREE; + } + if (currop->op1) + { + pre_expr scexpr = get_or_alloc_expr_for (currop->op1); + sc = find_or_generate_expression (block, scexpr, stmts, domstmt); + if (!sc) + return NULL_TREE; + } + args = XNEWVEC (tree, VEC_length (vn_reference_op_s, + ref->operands) - 1); while (*operand < VEC_length (vn_reference_op_s, ref->operands)) { args[nargs] = create_component_ref_by_pieces_1 (block, ref, operand, stmts, domstmt); + if (!args[nargs]) + { + free (args); + return NULL_TREE; + } nargs++; } folded = build_call_array (currop->type, - TREE_CODE (currop->op0) == FUNCTION_DECL - ? build_fold_addr_expr (currop->op0) - : currop->op0, + (TREE_CODE (fn) == FUNCTION_DECL + ? build_fold_addr_expr (fn) : fn), nargs, args); free (args); if (sc) - { - pre_expr scexpr = get_or_alloc_expr_for (sc); - sc = find_or_generate_expression (block, scexpr, stmts, domstmt); - if (!sc) - return NULL_TREE; - CALL_EXPR_STATIC_CHAIN (folded) = sc; - } + CALL_EXPR_STATIC_CHAIN (folded) = sc; return folded; } break; @@ -2779,22 +2794,37 @@ create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref, return NULL_TREE; if (genop2) { - op2expr = get_or_alloc_expr_for (genop2); - genop2 = find_or_generate_expression (block, op2expr, stmts, - domstmt); - if (!genop2) - return NULL_TREE; + /* Drop zero minimum index. */ + if (tree_int_cst_equal (genop2, integer_zero_node)) + genop2 = NULL_TREE; + else + { + op2expr = get_or_alloc_expr_for (genop2); + genop2 = find_or_generate_expression (block, op2expr, stmts, + domstmt); + if (!genop2) + return NULL_TREE; + } } if (genop3) { tree elmt_type = TREE_TYPE (TREE_TYPE (genop0)); - genop3 = size_binop (EXACT_DIV_EXPR, genop3, - size_int (TYPE_ALIGN_UNIT (elmt_type))); - op3expr = get_or_alloc_expr_for (genop3); - genop3 = find_or_generate_expression (block, op3expr, stmts, - domstmt); - if (!genop3) - return NULL_TREE; + /* We can't always put a size in units of the element alignment + here as the element alignment may be not visible. See + PR43783. Simply drop the element size for constant + sizes. */ + if (tree_int_cst_equal (genop3, TYPE_SIZE_UNIT (elmt_type))) + genop3 = NULL_TREE; + else + { + genop3 = size_binop (EXACT_DIV_EXPR, genop3, + size_int (TYPE_ALIGN_UNIT (elmt_type))); + op3expr = get_or_alloc_expr_for (genop3); + genop3 = find_or_generate_expression (block, op3expr, stmts, + domstmt); + if (!genop3) + return NULL_TREE; + } } return build4 (currop->opcode, currop->type, genop0, genop1, genop2, genop3); @@ -3073,17 +3103,13 @@ create_expression_by_pieces (basic_block block, pre_expr expr, that we will return. */ if (!pretemp || exprtype != TREE_TYPE (pretemp)) { - pretemp = create_tmp_var (exprtype, "pretmp"); + pretemp = create_tmp_reg (exprtype, "pretmp"); get_var_ann (pretemp); } temp = pretemp; add_referenced_var (temp); - if (TREE_CODE (exprtype) == COMPLEX_TYPE - || TREE_CODE (exprtype) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (temp) = 1; - newstmt = gimple_build_assign (temp, folded); name = make_ssa_name (temp, newstmt); gimple_assign_set_lhs (newstmt, name); diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index 8d1c05c86e1..aa080855e5b 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -489,11 +489,11 @@ eliminate_duplicate_pair (enum tree_code opcode, static VEC(tree, heap) *plus_negates; -/* If OPCODE is PLUS_EXPR, CURR->OP is really a negate expression, - look in OPS for a corresponding positive operation to cancel it - out. If we find one, remove the other from OPS, replace - OPS[CURRINDEX] with 0, and return true. Otherwise, return - false. */ +/* If OPCODE is PLUS_EXPR, CURR->OP is a negate expression or a bitwise not + expression, look in OPS for a corresponding positive operation to cancel + it out. If we find one, remove the other from OPS, replace + OPS[CURRINDEX] with 0 or -1, respectively, and return true. Otherwise, + return false. */ static bool eliminate_plus_minus_pair (enum tree_code opcode, @@ -502,6 +502,7 @@ eliminate_plus_minus_pair (enum tree_code opcode, operand_entry_t curr) { tree negateop; + tree notop; unsigned int i; operand_entry_t oe; @@ -509,7 +510,8 @@ eliminate_plus_minus_pair (enum tree_code opcode, return false; negateop = get_unary_op (curr->op, NEGATE_EXPR); - if (negateop == NULL_TREE) + notop = get_unary_op (curr->op, BIT_NOT_EXPR); + if (negateop == NULL_TREE && notop == NULL_TREE) return false; /* Any non-negated version will have a rank that is one less than @@ -541,11 +543,32 @@ eliminate_plus_minus_pair (enum tree_code opcode, return true; } + else if (oe->op == notop) + { + tree op_type = TREE_TYPE (oe->op); + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Equivalence: "); + print_generic_expr (dump_file, notop, 0); + fprintf (dump_file, " + ~"); + print_generic_expr (dump_file, oe->op, 0); + fprintf (dump_file, " -> -1\n"); + } + + VEC_ordered_remove (operand_entry_t, *ops, i); + add_to_ops_vec (ops, build_int_cst_type (op_type, -1)); + VEC_ordered_remove (operand_entry_t, *ops, currindex); + reassociate_stats.ops_eliminated ++; + + return true; + } } /* CURR->OP is a negate expr in a plus expr: save it for later inspection in repropagate_negates(). */ - VEC_safe_push (tree, heap, plus_negates, curr->op); + if (negateop != NULL_TREE) + VEC_safe_push (tree, heap, plus_negates, curr->op); return false; } diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index ad4c10d3261..207cb178115 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -1706,7 +1706,8 @@ do_sd_constraint (constraint_graph_t graph, constraint_t c, the set. Use ESCAPED as representative instead. */ else if (v->id == escaped_id) flag |= bitmap_set_bit (sol, escaped_id); - else if (add_graph_edge (graph, lhs, t)) + else if (v->may_have_pointers + && add_graph_edge (graph, lhs, t)) flag |= bitmap_ior_into (sol, get_varinfo (t)->solution); /* If the variable is not exactly at the requested offset @@ -1745,6 +1746,7 @@ do_ds_constraint (constraint_t c, bitmap delta) unsigned int j; bitmap_iterator bi; HOST_WIDE_INT loff = c->lhs.offset; + bool escaped_p = false; /* Our IL does not allow this. */ gcc_assert (c->rhs.offset == 0); @@ -1791,22 +1793,6 @@ do_ds_constraint (constraint_t c, bitmap delta) unsigned int t; HOST_WIDE_INT fieldoffset = v->offset + loff; - /* If v is a global variable then this is an escape point. */ - if (v->is_global_var) - { - t = find (escaped_id); - if (add_graph_edge (graph, t, rhs) - && bitmap_ior_into (get_varinfo (t)->solution, sol) - && !TEST_BIT (changed, t)) - { - SET_BIT (changed, t); - changed_count++; - } - } - - if (v->is_special_var) - continue; - if (v->is_full_var) fieldoffset = v->offset; else if (loff != 0) @@ -1819,6 +1805,25 @@ do_ds_constraint (constraint_t c, bitmap delta) { if (v->may_have_pointers) { + /* If v is a global variable then this is an escape point. */ + if (v->is_global_var + && !escaped_p) + { + t = find (escaped_id); + if (add_graph_edge (graph, t, rhs) + && bitmap_ior_into (get_varinfo (t)->solution, sol) + && !TEST_BIT (changed, t)) + { + SET_BIT (changed, t); + changed_count++; + } + /* Enough to let rhs escape once. */ + escaped_p = true; + } + + if (v->is_special_var) + break; + t = find (v->id); if (add_graph_edge (graph, t, rhs) && bitmap_ior_into (get_varinfo (t)->solution, sol) @@ -2885,6 +2890,16 @@ process_constraint (constraint_t t) /* ADDRESSOF on the lhs is invalid. */ gcc_assert (lhs.type != ADDRESSOF); + /* We shouldn't add constraints from things that cannot have pointers. + It's not completely trivial to avoid in the callers, so do it here. */ + if (rhs.type != ADDRESSOF + && !get_varinfo (rhs.var)->may_have_pointers) + return; + + /* Likewise adding to the solution of a non-pointer var isn't useful. */ + if (!get_varinfo (lhs.var)->may_have_pointers) + return; + /* This can happen in our IR with things like n->a = *p */ if (rhs.type == DEREF && lhs.type == DEREF && rhs.var != anything_id) { @@ -3403,7 +3418,19 @@ do_structure_copy (tree lhsop, tree rhsop) if (lhsp->type == DEREF || (lhsp->type == ADDRESSOF && lhsp->var == anything_id) || rhsp->type == DEREF) - process_all_all_constraints (lhsc, rhsc); + { + if (lhsp->type == DEREF) + { + gcc_assert (VEC_length (ce_s, lhsc) == 1); + lhsp->offset = UNKNOWN_OFFSET; + } + if (rhsp->type == DEREF) + { + gcc_assert (VEC_length (ce_s, rhsc) == 1); + rhsp->offset = UNKNOWN_OFFSET; + } + process_all_all_constraints (lhsc, rhsc); + } else if (lhsp->type == SCALAR && (rhsp->type == SCALAR || rhsp->type == ADDRESSOF)) @@ -5910,13 +5937,7 @@ dump_sa_points_to_info (FILE *outfile) { varinfo_t vi = get_varinfo (i); if (!vi->may_have_pointers) - { - gcc_assert (find (i) == i - || !(vi = get_varinfo (find (i)))->may_have_pointers); - /* ??? See create_variable_info_for. - gcc_assert (bitmap_empty_p (vi->solution)); */ - continue; - } + continue; dump_solution_for_var (outfile, i); } } @@ -5955,6 +5976,8 @@ init_base_vars (void) var_nothing->size = ~0; var_nothing->fullsize = ~0; var_nothing->is_special_var = 1; + var_nothing->may_have_pointers = 0; + var_nothing->is_global_var = 0; /* Create the ANYTHING variable, used to represent that a variable points to some unknown piece of memory. */ diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c index ca3dffadc75..4d2422aa623 100644 --- a/gcc/tree-tailcall.c +++ b/gcc/tree-tailcall.c @@ -575,13 +575,10 @@ adjust_return_value_with_ops (enum tree_code code, const char *label, { tree ret_type = TREE_TYPE (DECL_RESULT (current_function_decl)); - tree tmp = create_tmp_var (ret_type, label); + tree tmp = create_tmp_reg (ret_type, label); gimple stmt; tree result; - if (TREE_CODE (ret_type) == COMPLEX_TYPE - || TREE_CODE (ret_type) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (tmp) = 1; add_referenced_var (tmp); if (types_compatible_p (TREE_TYPE (acc), TREE_TYPE (op1))) @@ -908,12 +905,9 @@ static tree create_tailcall_accumulator (const char *label, basic_block bb, tree init) { tree ret_type = TREE_TYPE (DECL_RESULT (current_function_decl)); - tree tmp = create_tmp_var (ret_type, label); + tree tmp = create_tmp_reg (ret_type, label); gimple phi; - if (TREE_CODE (ret_type) == COMPLEX_TYPE - || TREE_CODE (ret_type) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (tmp) = 1; add_referenced_var (tmp); phi = create_phi_node (tmp, bb); /* RET_TYPE can be a float when -ffast-maths is enabled. */ diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c index 809f3e15a02..83b823d84bf 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -545,6 +545,11 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_reduction_def; STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) = vect_reduction_def; + /* Store the reduction cycles for possible vectorization in + loop-aware SLP. */ + VEC_safe_push (gimple, heap, + LOOP_VINFO_REDUCTIONS (loop_vinfo), + reduc_stmt); } } } @@ -745,6 +750,7 @@ new_loop_vec_info (struct loop *loop) VEC_alloc (ddr_p, heap, PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS)); LOOP_VINFO_STRIDED_STORES (res) = VEC_alloc (gimple, heap, 10); + LOOP_VINFO_REDUCTIONS (res) = VEC_alloc (gimple, heap, 10); LOOP_VINFO_SLP_INSTANCES (res) = VEC_alloc (slp_instance, heap, 10); LOOP_VINFO_SLP_UNROLLING_FACTOR (res) = 1; @@ -835,6 +841,7 @@ destroy_loop_vec_info (loop_vec_info loop_vinfo, bool clean_stmts) VEC_free (slp_instance, heap, LOOP_VINFO_SLP_INSTANCES (loop_vinfo)); VEC_free (gimple, heap, LOOP_VINFO_STRIDED_STORES (loop_vinfo)); + VEC_free (gimple, heap, LOOP_VINFO_REDUCTIONS (loop_vinfo)); free (loop_vinfo); loop->aux = NULL; @@ -1223,7 +1230,6 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo) if ((STMT_VINFO_RELEVANT_P (stmt_info) || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_info))) && !PURE_SLP_STMT (stmt_info)) - /* STMT needs both SLP and loop-based vectorization. */ only_slp_in_loop = false; } @@ -2860,28 +2866,33 @@ get_initial_def_for_reduction (gimple stmt, tree init_val, /* Function vect_create_epilog_for_reduction Create code at the loop-epilog to finalize the result of a reduction - computation. - - VECT_DEF is a vector of partial results. - REDUC_CODE is the tree-code for the epilog reduction. + computation. + + VECT_DEFS is list of vector of partial results, i.e., the lhs's of vector + reduction statements. + STMT is the scalar reduction stmt that is being vectorized. NCOPIES is > 1 in case the vectorization factor (VF) is bigger than the number of elements that we can fit in a vectype (nunits). In this case we have to generate more than one vector stmt - i.e - we need to "unroll" the vector stmt by a factor VF/nunits. For more details see documentation in vectorizable_operation. - STMT is the scalar reduction stmt that is being vectorized. - REDUCTION_PHI is the phi-node that carries the reduction computation. - REDUC_INDEX is the index of the operand in the right hand side of the + REDUC_CODE is the tree-code for the epilog reduction. + REDUCTION_PHIS is a list of the phi-nodes that carry the reduction + computation. + REDUC_INDEX is the index of the operand in the right hand side of the statement that is defined by REDUCTION_PHI. DOUBLE_REDUC is TRUE if double reduction phi nodes should be handled. + SLP_NODE is an SLP node containing a group of reduction statements. The + first one in this group is STMT. This function: - 1. Creates the reduction def-use cycle: sets the arguments for - REDUCTION_PHI: + 1. Creates the reduction def-use cycles: sets the arguments for + REDUCTION_PHIS: The loop-entry argument is the vectorized initial-value of the reduction. - The loop-latch argument is VECT_DEF - the vector of partial sums. - 2. "Reduces" the vector of partial results VECT_DEF into a single result, - by applying the operation specified by REDUC_CODE if available, or by + The loop-latch argument is taken from VECT_DEFS - the vector of partial + sums. + 2. "Reduces" each vector of partial results VECT_DEFS into a single result, + by applying the operation specified by REDUC_CODE if available, or by other means (whole-vector shifts or a scalar loop). The function also creates a new phi node at the loop exit to preserve loop-closed form, as illustrated below. @@ -2914,12 +2925,11 @@ get_initial_def_for_reduction (gimple stmt, tree init_val, */ static void -vect_create_epilog_for_reduction (tree vect_def, gimple stmt, - int ncopies, - enum tree_code reduc_code, - gimple reduction_phi, - int reduc_index, - bool double_reduc) +vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt, + int ncopies, enum tree_code reduc_code, + VEC (gimple, heap) *reduction_phis, + int reduc_index, bool double_reduc, + slp_tree slp_node) { stmt_vec_info stmt_info = vinfo_for_stmt (stmt); stmt_vec_info prev_phi_info; @@ -2933,32 +2943,37 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, gimple new_phi = NULL, phi; gimple_stmt_iterator exit_gsi; tree vec_dest; - tree new_temp = NULL_TREE; - tree new_name; + tree new_temp = NULL_TREE, new_dest, new_name, new_scalar_dest; gimple epilog_stmt = NULL; - tree new_scalar_dest, new_dest; + enum tree_code code = gimple_assign_rhs_code (stmt); gimple exit_phi; tree bitsize, bitpos; - enum tree_code code = gimple_assign_rhs_code (stmt); - tree adjustment_def; - tree vec_initial_def, def; - tree orig_name; + tree adjustment_def = NULL; + tree vec_initial_def = NULL; + tree reduction_op, expr, def; + tree orig_name, scalar_result; imm_use_iterator imm_iter; use_operand_p use_p; bool extract_scalar_result = false; - tree reduction_op, expr; - gimple orig_stmt; - gimple use_stmt; + gimple use_stmt, orig_stmt, reduction_phi = NULL; bool nested_in_vect_loop = false; - VEC(gimple,heap) *phis = NULL; + VEC (gimple, heap) *new_phis = NULL; enum vect_def_type dt = vect_unknown_def_type; int j, i; + VEC (tree, heap) *scalar_results = NULL; + unsigned int group_size = 1, k, ratio; + VEC (tree, heap) *vec_initial_defs = NULL; + VEC (gimple, heap) *phis; + + if (slp_node) + group_size = VEC_length (gimple, SLP_TREE_SCALAR_STMTS (slp_node)); if (nested_in_vect_loop_p (loop, stmt)) { outer_loop = loop; loop = loop->inner; nested_in_vect_loop = true; + gcc_assert (!slp_node); } switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))) @@ -2983,47 +2998,80 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, gcc_assert (vectype); mode = TYPE_MODE (vectype); - /*** 1. Create the reduction def-use cycle ***/ + /* 1. Create the reduction def-use cycle: + Set the arguments of REDUCTION_PHIS, i.e., transform + + loop: + vec_def = phi # REDUCTION_PHI + VECT_DEF = vector_stmt # vectorized form of STMT + ... - /* For the case of reduction, vect_get_vec_def_for_operand returns - the scalar def before the loop, that defines the initial value - of the reduction variable. */ - vec_initial_def = vect_get_vec_def_for_operand (reduction_op, stmt, - &adjustment_def); + into: - phi = reduction_phi; - def = vect_def; - for (j = 0; j < ncopies; j++) + loop: + vec_def = phi # REDUCTION_PHI + VECT_DEF = vector_stmt # vectorized form of STMT + ... + + (in case of SLP, do it for all the phis). */ + + /* Get the loop-entry arguments. */ + if (slp_node) + vect_get_slp_defs (slp_node, &vec_initial_defs, NULL, reduc_index); + else { - /* 1.1 set the loop-entry arg of the reduction-phi: */ - add_phi_arg (phi, vec_initial_def, loop_preheader_edge (loop), - UNKNOWN_LOCATION); + vec_initial_defs = VEC_alloc (tree, heap, 1); + /* For the case of reduction, vect_get_vec_def_for_operand returns + the scalar def before the loop, that defines the initial value + of the reduction variable. */ + vec_initial_def = vect_get_vec_def_for_operand (reduction_op, stmt, + &adjustment_def); + VEC_quick_push (tree, vec_initial_defs, vec_initial_def); + } - /* 1.2 set the loop-latch arg for the reduction-phi: */ - if (j > 0) - def = vect_get_vec_def_for_stmt_copy (dt, def); - add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION); + /* Set phi nodes arguments. */ + for (i = 0; VEC_iterate (gimple, reduction_phis, i, phi); i++) + { + tree vec_init_def = VEC_index (tree, vec_initial_defs, i); + tree def = VEC_index (tree, vect_defs, i); + for (j = 0; j < ncopies; j++) + { + /* Set the loop-entry arg of the reduction-phi. */ + add_phi_arg (phi, vec_init_def, loop_preheader_edge (loop), + UNKNOWN_LOCATION); - if (vect_print_dump_info (REPORT_DETAILS)) - { - fprintf (vect_dump, "transform reduction: created def-use cycle: "); - print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); - fprintf (vect_dump, "\n"); - print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (def), 0, TDF_SLIM); - } + /* Set the loop-latch arg for the reduction-phi. */ + if (j > 0) + def = vect_get_vec_def_for_stmt_copy (vect_unknown_def_type, def); - phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi)); + add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION); + + if (vect_print_dump_info (REPORT_DETAILS)) + { + fprintf (vect_dump, "transform reduction: created def-use" + " cycle: "); + print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM); + fprintf (vect_dump, "\n"); + print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (def), 0, + TDF_SLIM); + } + + phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi)); + } } - /*** 2. Create epilog code - The reduction epilog code operates across the elements of the vector - of partial results computed by the vectorized loop. - The reduction epilog code consists of: - step 1: compute the scalar result in a vector (v_out2) - step 2: extract the scalar result (s_out3) from the vector (v_out2) - step 3: adjust the scalar result (s_out3) if needed. + VEC_free (tree, heap, vec_initial_defs); + + /* 2. Create epilog code. + The reduction epilog code operates across the elements of the vector + of partial results computed by the vectorized loop. + The reduction epilog code consists of: + + step 1: compute the scalar result in a vector (v_out2) + step 2: extract the scalar result (s_out3) from the vector (v_out2) + step 3: adjust the scalar result (s_out3) if needed. - Step 1 can be accomplished using one the following three schemes: + Step 1 can be accomplished using one the following three schemes: (scheme 1) using reduc_code, if available. (scheme 2) using whole-vector shifts, if available. (scheme 3) using a scalar loop. In this case steps 1+2 above are @@ -3038,29 +3086,33 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, s_out4 = adjust_result # step 3 (step 3 is optional, and steps 1 and 2 may be combined). - Lastly, the uses of s_out0 are replaced by s_out4. + Lastly, the uses of s_out0 are replaced by s_out4. */ - ***/ - /* 2.1 Create new loop-exit-phi to preserve loop-closed form: - v_out1 = phi */ + /* 2.1 Create new loop-exit-phis to preserve loop-closed form: + v_out1 = phi + Store them in NEW_PHIS. */ exit_bb = single_exit (loop)->dest; - def = vect_def; prev_phi_info = NULL; - for (j = 0; j < ncopies; j++) + new_phis = VEC_alloc (gimple, heap, VEC_length (tree, vect_defs)); + for (i = 0; VEC_iterate (tree, vect_defs, i, def); i++) { - phi = create_phi_node (SSA_NAME_VAR (vect_def), exit_bb); - set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo, NULL)); - if (j == 0) - new_phi = phi; - else - { - def = vect_get_vec_def_for_stmt_copy (dt, def); - STMT_VINFO_RELATED_STMT (prev_phi_info) = phi; - } - SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def); - prev_phi_info = vinfo_for_stmt (phi); + for (j = 0; j < ncopies; j++) + { + phi = create_phi_node (SSA_NAME_VAR (def), exit_bb); + set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo, NULL)); + if (j == 0) + VEC_quick_push (gimple, new_phis, phi); + else + { + def = vect_get_vec_def_for_stmt_copy (dt, def); + STMT_VINFO_RELATED_STMT (prev_phi_info) = phi; + } + + SET_PHI_ARG_DEF (phi, single_exit (loop)->dest_idx, def); + prev_phi_info = vinfo_for_stmt (phi); + } } exit_gsi = gsi_after_labels (exit_bb); @@ -3089,16 +3141,17 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, } code = gimple_assign_rhs_code (orig_stmt); + /* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore, + partial results are added and not subtracted. */ + if (code == MINUS_EXPR) + code = PLUS_EXPR; + scalar_dest = gimple_assign_lhs (orig_stmt); scalar_type = TREE_TYPE (scalar_dest); + scalar_results = VEC_alloc (tree, heap, group_size); new_scalar_dest = vect_create_destination_var (scalar_dest, NULL); bitsize = TYPE_SIZE (scalar_type); - /* For MINUS_EXPR the initial vector is [init_val,0,...,0], therefore, - partial results are added and not subtracted. */ - if (code == MINUS_EXPR) - code = PLUS_EXPR; - /* In case this is a reduction in an inner-loop while vectorizing an outer loop - we don't need to extract a single scalar result at the end of the inner-loop (unless it is double reduction, i.e., the use of reduction is @@ -3108,28 +3161,21 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, if (nested_in_vect_loop && !double_reduc) goto vect_finalize_reduction; - /* The epilogue is created for the outer-loop, i.e., for the loop being - vectorized. */ - if (double_reduc) - loop = outer_loop; - - /* FORNOW */ - gcc_assert (ncopies == 1); - /* 2.3 Create the reduction code, using one of the three schemes described - above. */ - - if (reduc_code != ERROR_MARK) + above. In SLP we simply need to extract all the elements from the + vector (without reducing them), so we use scalar shifts. */ + if (reduc_code != ERROR_MARK && !slp_node) { tree tmp; /*** Case 1: Create: - v_out2 = reduc_expr */ + v_out2 = reduc_expr */ if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "Reduce using direct vector reduction."); + fprintf (vect_dump, "Reduce using direct vector reduction."); vec_dest = vect_create_destination_var (scalar_dest, vectype); + new_phi = VEC_index (gimple, new_phis, 0); tmp = build1 (reduc_code, vectype, PHI_RESULT (new_phi)); epilog_stmt = gimple_build_assign (vec_dest, tmp); new_temp = make_ssa_name (vec_dest, epilog_stmt); @@ -3148,142 +3194,182 @@ vect_create_epilog_for_reduction (tree vect_def, gimple stmt, tree vec_temp; if (optab_handler (vec_shr_optab, mode)->insn_code != CODE_FOR_nothing) - shift_code = VEC_RSHIFT_EXPR; + shift_code = VEC_RSHIFT_EXPR; else - have_whole_vector_shift = false; + have_whole_vector_shift = false; /* Regardless of whether we have a whole vector shift, if we're - emulating the operation via tree-vect-generic, we don't want - to use it. Only the first round of the reduction is likely - to still be profitable via emulation. */ + emulating the operation via tree-vect-generic, we don't want + to use it. Only the first round of the reduction is likely + to still be profitable via emulation. */ /* ??? It might be better to emit a reduction tree code here, so that - tree-vect-generic can expand the first round via bit tricks. */ + tree-vect-generic can expand the first round via bit tricks. */ if (!VECTOR_MODE_P (mode)) - have_whole_vector_shift = false; + have_whole_vector_shift = false; else - { - optab optab = optab_for_tree_code (code, vectype, optab_default); - if (optab_handler (optab, mode)->insn_code == CODE_FOR_nothing) - have_whole_vector_shift = false; - } - - if (have_whole_vector_shift) { - /*** Case 2: Create: - for (offset = VS/2; offset >= element_size; offset/=2) - { - Create: va' = vec_shift - Create: va = vop - } */ - - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "Reduce using vector shifts"); + optab optab = optab_for_tree_code (code, vectype, optab_default); + if (optab_handler (optab, mode)->insn_code == CODE_FOR_nothing) + have_whole_vector_shift = false; + } - vec_dest = vect_create_destination_var (scalar_dest, vectype); - new_temp = PHI_RESULT (new_phi); + if (have_whole_vector_shift && !slp_node) + { + /*** Case 2: Create: + for (offset = VS/2; offset >= element_size; offset/=2) + { + Create: va' = vec_shift + Create: va = vop + } */ - for (bit_offset = vec_size_in_bits/2; - bit_offset >= element_bitsize; - bit_offset /= 2) - { - tree bitpos = size_int (bit_offset); - - epilog_stmt = gimple_build_assign_with_ops (shift_code, vec_dest, - new_temp, bitpos); - new_name = make_ssa_name (vec_dest, epilog_stmt); - gimple_assign_set_lhs (epilog_stmt, new_name); - gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); - - epilog_stmt = gimple_build_assign_with_ops (code, vec_dest, - new_name, new_temp); - new_temp = make_ssa_name (vec_dest, epilog_stmt); - gimple_assign_set_lhs (epilog_stmt, new_temp); - gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); - } + if (vect_print_dump_info (REPORT_DETAILS)) + fprintf (vect_dump, "Reduce using vector shifts"); + + vec_dest = vect_create_destination_var (scalar_dest, vectype); + new_phi = VEC_index (gimple, new_phis, 0); + new_temp = PHI_RESULT (new_phi); + for (bit_offset = vec_size_in_bits/2; + bit_offset >= element_bitsize; + bit_offset /= 2) + { + tree bitpos = size_int (bit_offset); + + epilog_stmt = gimple_build_assign_with_ops (shift_code, + vec_dest, new_temp, bitpos); + new_name = make_ssa_name (vec_dest, epilog_stmt); + gimple_assign_set_lhs (epilog_stmt, new_name); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); + + epilog_stmt = gimple_build_assign_with_ops (code, vec_dest, + new_name, new_temp); + new_temp = make_ssa_name (vec_dest, epilog_stmt); + gimple_assign_set_lhs (epilog_stmt, new_temp); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); + } - extract_scalar_result = true; - } + extract_scalar_result = true; + } else { - tree rhs; - - /*** Case 3: Create: - s = extract_field - for (offset = element_size; - offset < vector_size; - offset += element_size;) - { - Create: s' = extract_field - Create: s = op - } */ + tree rhs; + + /*** Case 3: Create: + s = extract_field + for (offset = element_size; + offset < vector_size; + offset += element_size;) + { + Create: s' = extract_field + Create: s = op // For non SLP cases + } */ - if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "Reduce using scalar code. "); - - vec_temp = PHI_RESULT (new_phi); - vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1); - rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize, - bitsize_zero_node); - epilog_stmt = gimple_build_assign (new_scalar_dest, rhs); - new_temp = make_ssa_name (new_scalar_dest, epilog_stmt); - gimple_assign_set_lhs (epilog_stmt, new_temp); - gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); - - for (bit_offset = element_bitsize; - bit_offset < vec_size_in_bits; - bit_offset += element_bitsize) - { - tree bitpos = bitsize_int (bit_offset); - tree rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize, - bitpos); - - epilog_stmt = gimple_build_assign (new_scalar_dest, rhs); - new_name = make_ssa_name (new_scalar_dest, epilog_stmt); - gimple_assign_set_lhs (epilog_stmt, new_name); - gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); - - epilog_stmt = gimple_build_assign_with_ops (code, - new_scalar_dest, - new_name, new_temp); - new_temp = make_ssa_name (new_scalar_dest, epilog_stmt); - gimple_assign_set_lhs (epilog_stmt, new_temp); - gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); - } + if (vect_print_dump_info (REPORT_DETAILS)) + fprintf (vect_dump, "Reduce using scalar code. "); - extract_scalar_result = false; - } + vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1); + for (i = 0; VEC_iterate (gimple, new_phis, i, new_phi); i++) + { + vec_temp = PHI_RESULT (new_phi); + rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize, + bitsize_zero_node); + epilog_stmt = gimple_build_assign (new_scalar_dest, rhs); + new_temp = make_ssa_name (new_scalar_dest, epilog_stmt); + gimple_assign_set_lhs (epilog_stmt, new_temp); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); + + /* In SLP we don't need to apply reduction operation, so we just + collect s' values in SCALAR_RESULTS. */ + if (slp_node) + VEC_safe_push (tree, heap, scalar_results, new_temp); + + for (bit_offset = element_bitsize; + bit_offset < vec_size_in_bits; + bit_offset += element_bitsize) + { + tree bitpos = bitsize_int (bit_offset); + tree rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, + bitsize, bitpos); + + epilog_stmt = gimple_build_assign (new_scalar_dest, rhs); + new_name = make_ssa_name (new_scalar_dest, epilog_stmt); + gimple_assign_set_lhs (epilog_stmt, new_name); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); + + if (slp_node) + { + /* In SLP we don't need to apply reduction operation, so + we just collect s' values in SCALAR_RESULTS. */ + new_temp = new_name; + VEC_safe_push (tree, heap, scalar_results, new_name); + } + else + { + epilog_stmt = gimple_build_assign_with_ops (code, + new_scalar_dest, new_name, new_temp); + new_temp = make_ssa_name (new_scalar_dest, epilog_stmt); + gimple_assign_set_lhs (epilog_stmt, new_temp); + gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); + } + } + } + + /* The only case where we need to reduce scalar results in SLP, is + unrolling. If the size of SCALAR_RESULTS is greater than + GROUP_SIZE, we reduce them combining elements modulo + GROUP_SIZE. */ + if (slp_node) + { + tree res, first_res, new_res; + gimple new_stmt; + + /* Reduce multiple scalar results in case of SLP unrolling. */ + for (j = group_size; VEC_iterate (tree, scalar_results, j, res); + j++) + { + first_res = VEC_index (tree, scalar_results, j % group_size); + new_stmt = gimple_build_assign_with_ops (code, + new_scalar_dest, first_res, res); + new_res = make_ssa_name (new_scalar_dest, new_stmt); + gimple_assign_set_lhs (new_stmt, new_res); + gsi_insert_before (&exit_gsi, new_stmt, GSI_SAME_STMT); + VEC_replace (tree, scalar_results, j % group_size, new_res); + } + } + else + /* Not SLP - we have one scalar to keep in SCALAR_RESULTS. */ + VEC_safe_push (tree, heap, scalar_results, new_temp); + + extract_scalar_result = false; + } } /* 2.4 Extract the final scalar result. Create: - s_out3 = extract_field */ + s_out3 = extract_field */ if (extract_scalar_result) { tree rhs; - gcc_assert (!nested_in_vect_loop || double_reduc); if (vect_print_dump_info (REPORT_DETAILS)) - fprintf (vect_dump, "extract scalar result"); + fprintf (vect_dump, "extract scalar result"); if (BYTES_BIG_ENDIAN) - bitpos = size_binop (MULT_EXPR, - bitsize_int (TYPE_VECTOR_SUBPARTS (vectype) - 1), - TYPE_SIZE (scalar_type)); + bitpos = size_binop (MULT_EXPR, + bitsize_int (TYPE_VECTOR_SUBPARTS (vectype) - 1), + TYPE_SIZE (scalar_type)); else - bitpos = bitsize_zero_node; + bitpos = bitsize_zero_node; rhs = build3 (BIT_FIELD_REF, scalar_type, new_temp, bitsize, bitpos); epilog_stmt = gimple_build_assign (new_scalar_dest, rhs); new_temp = make_ssa_name (new_scalar_dest, epilog_stmt); gimple_assign_set_lhs (epilog_stmt, new_temp); gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); + VEC_safe_push (tree, heap, scalar_results, new_temp); } - + vect_finalize_reduction: - if (double_reduc) - loop = loop->inner; - /* 2.5 Adjust the final result by the initial value of the reduction variable. (When such adjustment is not needed, then 'adjustment_def' is zero). For example, if code is PLUS we create: @@ -3291,14 +3377,17 @@ vect_finalize_reduction: if (adjustment_def) { + gcc_assert (!slp_node); if (nested_in_vect_loop) { + new_phi = VEC_index (gimple, new_phis, 0); gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) == VECTOR_TYPE); expr = build2 (code, vectype, PHI_RESULT (new_phi), adjustment_def); new_dest = vect_create_destination_var (scalar_dest, vectype); } else { + new_temp = VEC_index (tree, scalar_results, 0); gcc_assert (TREE_CODE (TREE_TYPE (adjustment_def)) != VECTOR_TYPE); expr = build2 (code, scalar_type, new_temp, adjustment_def); new_dest = vect_create_destination_var (scalar_dest, scalar_type); @@ -3309,142 +3398,212 @@ vect_finalize_reduction: gimple_assign_set_lhs (epilog_stmt, new_temp); SSA_NAME_DEF_STMT (new_temp) = epilog_stmt; gsi_insert_before (&exit_gsi, epilog_stmt, GSI_SAME_STMT); + if (nested_in_vect_loop) + { + set_vinfo_for_stmt (epilog_stmt, + new_stmt_vec_info (epilog_stmt, loop_vinfo, + NULL)); + STMT_VINFO_RELATED_STMT (vinfo_for_stmt (epilog_stmt)) = + STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_phi)); + + if (!double_reduc) + VEC_quick_push (tree, scalar_results, new_temp); + else + VEC_replace (tree, scalar_results, 0, new_temp); + } + else + VEC_replace (tree, scalar_results, 0, new_temp); + + VEC_replace (gimple, new_phis, 0, epilog_stmt); } + /* 2.6 Handle the loop-exit phis. Replace the uses of scalar loop-exit + phis with new adjusted scalar results, i.e., replace use + with use . + + Transform: + loop_exit: + s_out0 = phi # (scalar) EXIT_PHI + v_out1 = phi # NEW_EXIT_PHI + v_out2 = reduce + s_out3 = extract_field + s_out4 = adjust_result + use + use - /* 2.6 Handle the loop-exit phi */ + into: - /* Replace uses of s_out0 with uses of s_out3: - Find the loop-closed-use at the loop exit of the original scalar result. - (The reduction result is expected to have two immediate uses - one at the - latch block, and one at the loop exit). */ - phis = VEC_alloc (gimple, heap, 10); - FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest) + loop_exit: + s_out0 = phi # (scalar) EXIT_PHI + v_out1 = phi # NEW_EXIT_PHI + v_out2 = reduce + s_out3 = extract_field + s_out4 = adjust_result + use + use */ + + /* In SLP we may have several statements in NEW_PHIS and REDUCTION_PHIS (in + case that GROUP_SIZE is greater than vectorization factor). Therefore, we + need to match SCALAR_RESULTS with corresponding statements. The first + (GROUP_SIZE / number of new vector stmts) scalar results correspond to + the first vector stmt, etc. + (RATIO is equal to (GROUP_SIZE / number of new vector stmts)). */ + if (group_size > VEC_length (gimple, new_phis)) { - if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p)))) - { - exit_phi = USE_STMT (use_p); - VEC_quick_push (gimple, phis, exit_phi); - } + ratio = group_size / VEC_length (gimple, new_phis); + gcc_assert (!(group_size % VEC_length (gimple, new_phis))); } + else + ratio = 1; - /* We expect to have found an exit_phi because of loop-closed-ssa form. */ - gcc_assert (!VEC_empty (gimple, phis)); - - for (i = 0; VEC_iterate (gimple, phis, i, exit_phi); i++) + for (k = 0; k < group_size; k++) { - if (nested_in_vect_loop) - { - stmt_vec_info stmt_vinfo = vinfo_for_stmt (exit_phi); - gimple vect_phi; - - /* FORNOW. Currently not supporting the case that an inner-loop - reduction is not used in the outer-loop (but only outside the - outer-loop), unless it is double reduction. */ - gcc_assert ((STMT_VINFO_RELEVANT_P (stmt_vinfo) - && !STMT_VINFO_LIVE_P (stmt_vinfo)) || double_reduc); - - epilog_stmt = adjustment_def ? epilog_stmt : new_phi; - STMT_VINFO_VEC_STMT (stmt_vinfo) = epilog_stmt; - set_vinfo_for_stmt (epilog_stmt, - new_stmt_vec_info (epilog_stmt, loop_vinfo, - NULL)); - if (adjustment_def) - STMT_VINFO_RELATED_STMT (vinfo_for_stmt (epilog_stmt)) = - STMT_VINFO_RELATED_STMT (vinfo_for_stmt (new_phi)); - - if (!double_reduc - || STMT_VINFO_DEF_TYPE (stmt_vinfo) != vect_double_reduction_def) - continue; - - /* Handle double reduction: - - stmt1: s1 = phi - double reduction phi (outer loop) - stmt2: s3 = phi - (regular) reduction phi (inner loop) - stmt3: s4 = use (s3) - (regular) reduction stmt (inner loop) - stmt4: s2 = phi - double reduction stmt (outer loop) - - At that point the regular reduction (stmt2 and stmt3) is already - vectorized, as well as the exit phi node, stmt4. - Here we vectorize the phi node of double reduction, stmt1, and - update all relevant statements. */ - - /* Go through all the uses of s2 to find double reduction phi node, - i.e., stmt1 above. */ - orig_name = PHI_RESULT (exit_phi); - FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name) + if (k % ratio == 0) + { + epilog_stmt = VEC_index (gimple, new_phis, k / ratio); + reduction_phi = VEC_index (gimple, reduction_phis, k / ratio); + } + + if (slp_node) + { + gimple current_stmt = VEC_index (gimple, + SLP_TREE_SCALAR_STMTS (slp_node), k); + + orig_stmt = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (current_stmt)); + /* SLP statements can't participate in patterns. */ + gcc_assert (!orig_stmt); + scalar_dest = gimple_assign_lhs (current_stmt); + } + + phis = VEC_alloc (gimple, heap, 3); + /* Find the loop-closed-use at the loop exit of the original scalar + result. (The reduction result is expected to have two immediate uses - + one at the latch block, and one at the loop exit). */ + FOR_EACH_IMM_USE_FAST (use_p, imm_iter, scalar_dest) + if (!flow_bb_inside_loop_p (loop, gimple_bb (USE_STMT (use_p)))) + VEC_safe_push (gimple, heap, phis, USE_STMT (use_p)); + + /* We expect to have found an exit_phi because of loop-closed-ssa + form. */ + gcc_assert (!VEC_empty (gimple, phis)); + + for (i = 0; VEC_iterate (gimple, phis, i, exit_phi); i++) + { + if (outer_loop) { - stmt_vec_info use_stmt_vinfo = vinfo_for_stmt (use_stmt); - stmt_vec_info new_phi_vinfo; - tree vect_phi_init, preheader_arg, vect_phi_res, init_def; - basic_block bb = gimple_bb (use_stmt); - gimple use; - - /* Check that USE_STMT is really double reduction phi node. */ - if (gimple_code (use_stmt) != GIMPLE_PHI - || gimple_phi_num_args (use_stmt) != 2 - || !use_stmt_vinfo - || STMT_VINFO_DEF_TYPE (use_stmt_vinfo) - != vect_double_reduction_def - || bb->loop_father != outer_loop) + stmt_vec_info exit_phi_vinfo = vinfo_for_stmt (exit_phi); + gimple vect_phi; + + /* FORNOW. Currently not supporting the case that an inner-loop + reduction is not used in the outer-loop (but only outside the + outer-loop), unless it is double reduction. */ + gcc_assert ((STMT_VINFO_RELEVANT_P (exit_phi_vinfo) + && !STMT_VINFO_LIVE_P (exit_phi_vinfo)) + || double_reduc); + + STMT_VINFO_VEC_STMT (exit_phi_vinfo) = epilog_stmt; + if (!double_reduc + || STMT_VINFO_DEF_TYPE (exit_phi_vinfo) + != vect_double_reduction_def) continue; - /* Create vector phi node for double reduction: - vs1 = phi - vs1 was created previously in this function by a call to - vect_get_vec_def_for_operand and is stored in vec_initial_def; - vs2 is defined by EPILOG_STMT, the vectorized EXIT_PHI; - vs0 is created here. */ + /* Handle double reduction: - /* Create vector phi node. */ - vect_phi = create_phi_node (vec_initial_def, bb); - new_phi_vinfo = new_stmt_vec_info (vect_phi, - loop_vec_info_for_loop (outer_loop), NULL); - set_vinfo_for_stmt (vect_phi, new_phi_vinfo); - - /* Create vs0 - initial def of the double reduction phi. */ - preheader_arg = PHI_ARG_DEF_FROM_EDGE (use_stmt, - loop_preheader_edge (outer_loop)); - init_def = get_initial_def_for_reduction (stmt, preheader_arg, - NULL); - vect_phi_init = vect_init_vector (use_stmt, init_def, vectype, - NULL); - - /* Update phi node arguments with vs0 and vs2. */ - add_phi_arg (vect_phi, vect_phi_init, - loop_preheader_edge (outer_loop), UNKNOWN_LOCATION); - add_phi_arg (vect_phi, PHI_RESULT (epilog_stmt), - loop_latch_edge (outer_loop), UNKNOWN_LOCATION); - if (vect_print_dump_info (REPORT_DETAILS)) - { - fprintf (vect_dump, "created double reduction phi node: "); - print_gimple_stmt (vect_dump, vect_phi, 0, TDF_SLIM); - } + stmt1: s1 = phi - double reduction phi (outer loop) + stmt2: s3 = phi - (regular) reduc phi (inner loop) + stmt3: s4 = use (s3) - (regular) reduc stmt (inner loop) + stmt4: s2 = phi - double reduction stmt (outer loop) - vect_phi_res = PHI_RESULT (vect_phi); + At that point the regular reduction (stmt2 and stmt3) is + already vectorized, as well as the exit phi node, stmt4. + Here we vectorize the phi node of double reduction, stmt1, and + update all relevant statements. */ - /* Replace the use, i.e., set the correct vs1 in the regular - reduction phi node. FORNOW, NCOPIES is always 1, so the loop - is redundant. */ - use = reduction_phi; - for (j = 0; j < ncopies; j++) + /* Go through all the uses of s2 to find double reduction phi + node, i.e., stmt1 above. */ + orig_name = PHI_RESULT (exit_phi); + FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name) { - edge pr_edge = loop_preheader_edge (loop); - SET_PHI_ARG_DEF (use, pr_edge->dest_idx, vect_phi_res); - use = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use)); + stmt_vec_info use_stmt_vinfo = vinfo_for_stmt (use_stmt); + stmt_vec_info new_phi_vinfo; + tree vect_phi_init, preheader_arg, vect_phi_res, init_def; + basic_block bb = gimple_bb (use_stmt); + gimple use; + + /* Check that USE_STMT is really double reduction phi + node. */ + if (gimple_code (use_stmt) != GIMPLE_PHI + || gimple_phi_num_args (use_stmt) != 2 + || !use_stmt_vinfo + || STMT_VINFO_DEF_TYPE (use_stmt_vinfo) + != vect_double_reduction_def + || bb->loop_father != outer_loop) + continue; + + /* Create vector phi node for double reduction: + vs1 = phi + vs1 was created previously in this function by a call to + vect_get_vec_def_for_operand and is stored in + vec_initial_def; + vs2 is defined by EPILOG_STMT, the vectorized EXIT_PHI; + vs0 is created here. */ + + /* Create vector phi node. */ + vect_phi = create_phi_node (vec_initial_def, bb); + new_phi_vinfo = new_stmt_vec_info (vect_phi, + loop_vec_info_for_loop (outer_loop), NULL); + set_vinfo_for_stmt (vect_phi, new_phi_vinfo); + + /* Create vs0 - initial def of the double reduction phi. */ + preheader_arg = PHI_ARG_DEF_FROM_EDGE (use_stmt, + loop_preheader_edge (outer_loop)); + init_def = get_initial_def_for_reduction (stmt, + preheader_arg, NULL); + vect_phi_init = vect_init_vector (use_stmt, init_def, + vectype, NULL); + + /* Update phi node arguments with vs0 and vs2. */ + add_phi_arg (vect_phi, vect_phi_init, + loop_preheader_edge (outer_loop), + UNKNOWN_LOCATION); + add_phi_arg (vect_phi, PHI_RESULT (epilog_stmt), + loop_latch_edge (outer_loop), UNKNOWN_LOCATION); + if (vect_print_dump_info (REPORT_DETAILS)) + { + fprintf (vect_dump, "created double reduction phi " + "node: "); + print_gimple_stmt (vect_dump, vect_phi, 0, TDF_SLIM); + } + + vect_phi_res = PHI_RESULT (vect_phi); + + /* Replace the use, i.e., set the correct vs1 in the regular + reduction phi node. FORNOW, NCOPIES is always 1, so the + loop is redundant. */ + use = reduction_phi; + for (j = 0; j < ncopies; j++) + { + edge pr_edge = loop_preheader_edge (loop); + SET_PHI_ARG_DEF (use, pr_edge->dest_idx, vect_phi_res); + use = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use)); + } } } - } - /* Replace the uses: */ - orig_name = PHI_RESULT (exit_phi); - FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name) - FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) - SET_USE (use_p, new_temp); + /* Replace the uses: */ + orig_name = PHI_RESULT (exit_phi); + scalar_result = VEC_index (tree, scalar_results, k); + FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, orig_name) + FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) + SET_USE (use_p, scalar_result); + } + + VEC_free (gimple, heap, phis); } - VEC_free (gimple, heap, phis); -} + VEC_free (tree, heap, scalar_results); + VEC_free (gimple, heap, new_phis); +} /* Function vectorizable_reduction. @@ -3489,7 +3648,7 @@ vect_finalize_reduction: bool vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, - gimple *vec_stmt) + gimple *vec_stmt, slp_tree slp_node) { tree vec_dest; tree scalar_dest; @@ -3517,7 +3676,6 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, int ncopies; int epilog_copies; stmt_vec_info prev_stmt_info, prev_phi_info; - gimple first_phi = NULL; bool single_defuse_cycle = false; tree reduc_def = NULL_TREE; gimple new_stmt = NULL; @@ -3532,6 +3690,10 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, struct loop * def_stmt_loop, *outer_loop = NULL; tree def_arg; gimple def_arg_stmt; + VEC (tree, heap) *vec_oprnds0 = NULL, *vec_oprnds1 = NULL, *vect_defs = NULL; + VEC (gimple, heap) *phis = NULL; + int vec_num; + tree def0, def1; if (nested_in_vect_loop_p (loop, stmt)) { @@ -3540,10 +3702,6 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, nested_cycle = true; } - /* FORNOW: SLP not supported. */ - if (STMT_SLP_TYPE (stmt_info)) - return false; - /* 1. Is vectorizable reduction? */ /* Not supportable if the reduction variable is used in the loop. */ if (STMT_VINFO_RELEVANT (stmt_info) > vect_used_in_outer) @@ -3676,9 +3834,12 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, if (STMT_VINFO_LIVE_P (vinfo_for_stmt (reduc_def_stmt))) return false; + if (slp_node) + ncopies = 1; + else + ncopies = (LOOP_VINFO_VECT_FACTOR (loop_vinfo) + / TYPE_VECTOR_SUBPARTS (vectype_in)); - ncopies = (LOOP_VINFO_VECT_FACTOR (loop_vinfo) - / TYPE_VECTOR_SUBPARTS (vectype_in)); gcc_assert (ncopies >= 1); vec_mode = TYPE_MODE (vectype_in); @@ -3897,23 +4058,48 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, prev_stmt_info = NULL; prev_phi_info = NULL; + if (slp_node) + { + vec_num = SLP_TREE_NUMBER_OF_VEC_STMTS (slp_node); + gcc_assert (TYPE_VECTOR_SUBPARTS (vectype_out) + == TYPE_VECTOR_SUBPARTS (vectype_in)); + } + else + { + vec_num = 1; + vec_oprnds0 = VEC_alloc (tree, heap, 1); + if (op_type == ternary_op) + vec_oprnds1 = VEC_alloc (tree, heap, 1); + } + + phis = VEC_alloc (gimple, heap, vec_num); + vect_defs = VEC_alloc (tree, heap, vec_num); + if (!slp_node) + VEC_quick_push (tree, vect_defs, NULL_TREE); + for (j = 0; j < ncopies; j++) { if (j == 0 || !single_defuse_cycle) { - /* Create the reduction-phi that defines the reduction-operand. */ - new_phi = create_phi_node (vec_dest, loop->header); - set_vinfo_for_stmt (new_phi, new_stmt_vec_info (new_phi, loop_vinfo, - NULL)); - /* Get the vector def for the reduction variable from the phi - node. */ - reduc_def = PHI_RESULT (new_phi); - } + for (i = 0; i < vec_num; i++) + { + /* Create the reduction-phi that defines the reduction + operand. */ + new_phi = create_phi_node (vec_dest, loop->header); + set_vinfo_for_stmt (new_phi, + new_stmt_vec_info (new_phi, loop_vinfo, + NULL)); + if (j == 0 || slp_node) + VEC_quick_push (gimple, phis, new_phi); + } + } if (code == COND_EXPR) { - first_phi = new_phi; - vectorizable_condition (stmt, gsi, vec_stmt, reduc_def, reduc_index); + gcc_assert (!slp_node); + vectorizable_condition (stmt, gsi, vec_stmt, + PHI_RESULT (VEC_index (gimple, phis, 0)), + reduc_index); /* Multiple types are not supported for condition. */ break; } @@ -3921,65 +4107,94 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, /* Handle uses. */ if (j == 0) { - loop_vec_def0 = vect_get_vec_def_for_operand (ops[!reduc_index], - stmt, NULL); - if (op_type == ternary_op) + if (slp_node) + vect_get_slp_defs (slp_node, &vec_oprnds0, &vec_oprnds1, -1); + else { - if (reduc_index == 0) - loop_vec_def1 = vect_get_vec_def_for_operand (ops[2], stmt, - NULL); - else - loop_vec_def1 = vect_get_vec_def_for_operand (ops[1], stmt, - NULL); + loop_vec_def0 = vect_get_vec_def_for_operand (ops[!reduc_index], + stmt, NULL); + VEC_quick_push (tree, vec_oprnds0, loop_vec_def0); + if (op_type == ternary_op) + { + if (reduc_index == 0) + loop_vec_def1 = vect_get_vec_def_for_operand (ops[2], stmt, + NULL); + else + loop_vec_def1 = vect_get_vec_def_for_operand (ops[1], stmt, + NULL); + + VEC_quick_push (tree, vec_oprnds1, loop_vec_def1); + } } - - /* Get the vector def for the reduction variable from the phi - node. */ - first_phi = new_phi; } else { - enum vect_def_type dt = vect_unknown_def_type; /* Dummy */ - loop_vec_def0 = vect_get_vec_def_for_stmt_copy (dt, loop_vec_def0); - if (op_type == ternary_op) - loop_vec_def1 = vect_get_vec_def_for_stmt_copy (dt, loop_vec_def1); + if (!slp_node) + { + enum vect_def_type dt = vect_unknown_def_type; /* Dummy */ + loop_vec_def0 = vect_get_vec_def_for_stmt_copy (dt, loop_vec_def0); + VEC_replace (tree, vec_oprnds0, 0, loop_vec_def0); + if (op_type == ternary_op) + { + loop_vec_def1 = vect_get_vec_def_for_stmt_copy (dt, + loop_vec_def1); + VEC_replace (tree, vec_oprnds1, 0, loop_vec_def1); + } + } - if (single_defuse_cycle) - reduc_def = gimple_assign_lhs (new_stmt); - else - reduc_def = PHI_RESULT (new_phi); + if (single_defuse_cycle) + reduc_def = gimple_assign_lhs (new_stmt); - STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi; + STMT_VINFO_RELATED_STMT (prev_phi_info) = new_phi; } - /* Arguments are ready. Create the new vector stmt. */ - if (op_type == binary_op) + for (i = 0; VEC_iterate (tree, vec_oprnds0, i, def0); i++) { - if (reduc_index == 0) - expr = build2 (code, vectype_out, reduc_def, loop_vec_def0); + if (slp_node) + reduc_def = PHI_RESULT (VEC_index (gimple, phis, i)); else - expr = build2 (code, vectype_out, loop_vec_def0, reduc_def); - } - else - { - if (reduc_index == 0) - expr = build3 (code, vectype_out, reduc_def, loop_vec_def0, - loop_vec_def1); + { + if (!single_defuse_cycle || j == 0) + reduc_def = PHI_RESULT (new_phi); + } + + def1 = ((op_type == ternary_op) + ? VEC_index (tree, vec_oprnds1, i) : NULL); + if (op_type == binary_op) + { + if (reduc_index == 0) + expr = build2 (code, vectype_out, reduc_def, def0); + else + expr = build2 (code, vectype_out, def0, reduc_def); + } else { - if (reduc_index == 1) - expr = build3 (code, vectype_out, loop_vec_def0, reduc_def, - loop_vec_def1); + if (reduc_index == 0) + expr = build3 (code, vectype_out, reduc_def, def0, def1); else - expr = build3 (code, vectype_out, loop_vec_def0, loop_vec_def1, - reduc_def); + { + if (reduc_index == 1) + expr = build3 (code, vectype_out, def0, reduc_def, def1); + else + expr = build3 (code, vectype_out, def0, def1, reduc_def); + } + } + + new_stmt = gimple_build_assign (vec_dest, expr); + new_temp = make_ssa_name (vec_dest, new_stmt); + gimple_assign_set_lhs (new_stmt, new_temp); + vect_finish_stmt_generation (stmt, new_stmt, gsi); + if (slp_node) + { + VEC_quick_push (gimple, SLP_TREE_VEC_STMTS (slp_node), new_stmt); + VEC_quick_push (tree, vect_defs, new_temp); } + else + VEC_replace (tree, vect_defs, 0, new_temp); } - new_stmt = gimple_build_assign (vec_dest, expr); - new_temp = make_ssa_name (vec_dest, new_stmt); - gimple_assign_set_lhs (new_stmt, new_temp); - vect_finish_stmt_generation (stmt, new_stmt, gsi); + if (slp_node) + continue; if (j == 0) STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt; @@ -3992,12 +4207,21 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi, /* Finalize the reduction-phi (set its arguments) and create the epilog reduction code. */ - if (!single_defuse_cycle || code == COND_EXPR) - new_temp = gimple_assign_lhs (*vec_stmt); + if ((!single_defuse_cycle || code == COND_EXPR) && !slp_node) + { + new_temp = gimple_assign_lhs (*vec_stmt); + VEC_replace (tree, vect_defs, 0, new_temp); + } + + vect_create_epilog_for_reduction (vect_defs, stmt, epilog_copies, + epilog_reduc_code, phis, reduc_index, + double_reduc, slp_node); + + VEC_free (gimple, heap, phis); + VEC_free (tree, heap, vec_oprnds0); + if (vec_oprnds1) + VEC_free (tree, heap, vec_oprnds1); - vect_create_epilog_for_reduction (new_temp, stmt, epilog_copies, - epilog_reduc_code, first_phi, reduc_index, - double_reduc); return true; } diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c index 55b9d50cca0..ea827559195 100644 --- a/gcc/tree-vect-patterns.c +++ b/gcc/tree-vect-patterns.c @@ -670,6 +670,8 @@ vect_pattern_recog_1 ( tree pattern_vectype; tree type_in, type_out; enum tree_code code; + int i; + gimple next; pattern_stmt = (* vect_recog_func) (stmt, &type_in, &type_out); if (!pattern_stmt) @@ -735,7 +737,13 @@ vect_pattern_recog_1 ( STMT_VINFO_IN_PATTERN_P (stmt_info) = true; STMT_VINFO_RELATED_STMT (stmt_info) = pattern_stmt; - return; + /* Patterns cannot be vectorized using SLP, because they change the order of + computation. */ + for (i = 0; VEC_iterate (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo), i, + next); + i++) + if (next == stmt) + VEC_ordered_remove (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo), i); } diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c index d25d34787e0..6949ebdf873 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -273,6 +273,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, break; case vect_internal_def: + case vect_reduction_def: if (i == 0) VEC_safe_push (gimple, heap, *def_stmts0, def_stmt); else @@ -332,7 +333,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, HOST_WIDE_INT dummy; bool permutation = false; unsigned int load_place; - gimple first_load; + gimple first_load, prev_first_load = NULL; /* For every stmt in NODE find its def stmt/s. */ for (i = 0; VEC_iterate (gimple, stmts, i, stmt); i++) @@ -485,42 +486,62 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, &pattern0, &pattern1)) return false; } - else - { - /* Load. */ - /* FORNOW: Check that there is no gap between the loads. */ - if ((DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) == stmt - && DR_GROUP_GAP (vinfo_for_stmt (stmt)) != 0) - || (DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) != stmt - && DR_GROUP_GAP (vinfo_for_stmt (stmt)) != 1)) - { - if (vect_print_dump_info (REPORT_SLP)) - { - fprintf (vect_dump, "Build SLP failed: strided " - "loads have gaps "); - print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); - } + else + { + /* Load. */ + /* FORNOW: Check that there is no gap between the loads. */ + if ((DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) == stmt + && DR_GROUP_GAP (vinfo_for_stmt (stmt)) != 0) + || (DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) != stmt + && DR_GROUP_GAP (vinfo_for_stmt (stmt)) != 1)) + { + if (vect_print_dump_info (REPORT_SLP)) + { + fprintf (vect_dump, "Build SLP failed: strided " + "loads have gaps "); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); + } - return false; - } - - /* Check that the size of interleaved loads group is not - greater than the SLP group size. */ - if (DR_GROUP_SIZE (vinfo_for_stmt (stmt)) - > ncopies * group_size) - { - if (vect_print_dump_info (REPORT_SLP)) - { - fprintf (vect_dump, "Build SLP failed: the number of " - "interleaved loads is greater than" - " the SLP group size "); - print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); - } + return false; + } - return false; - } + /* Check that the size of interleaved loads group is not + greater than the SLP group size. */ + if (DR_GROUP_SIZE (vinfo_for_stmt (stmt)) > ncopies * group_size) + { + if (vect_print_dump_info (REPORT_SLP)) + { + fprintf (vect_dump, "Build SLP failed: the number of " + "interleaved loads is greater than" + " the SLP group size "); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); + } + + return false; + } - first_load = DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)); + first_load = DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)); + if (prev_first_load) + { + /* Check that there are no loads from different interleaving + chains in the same node. The only exception is complex + numbers. */ + if (prev_first_load != first_load + && rhs_code != REALPART_EXPR + && rhs_code != IMAGPART_EXPR) + { + if (vect_print_dump_info (REPORT_SLP)) + { + fprintf (vect_dump, "Build SLP failed: different " + "interleaving chains in one node "); + print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM); + } + + return false; + } + } + else + prev_first_load = first_load; if (first_load == stmt) { @@ -787,6 +808,39 @@ vect_supported_slp_permutation_p (slp_instance instance) } +/* Rearrange the statements of NODE according to PERMUTATION. */ + +static void +vect_slp_rearrange_stmts (slp_tree node, unsigned int group_size, + VEC (int, heap) *permutation) +{ + gimple stmt; + VEC (gimple, heap) *tmp_stmts; + unsigned int index, i; + + if (!node) + return; + + vect_slp_rearrange_stmts (SLP_TREE_LEFT (node), group_size, permutation); + vect_slp_rearrange_stmts (SLP_TREE_RIGHT (node), group_size, permutation); + + gcc_assert (group_size == VEC_length (gimple, SLP_TREE_SCALAR_STMTS (node))); + tmp_stmts = VEC_alloc (gimple, heap, group_size); + + for (i = 0; i < group_size; i++) + VEC_safe_push (gimple, heap, tmp_stmts, NULL); + + for (i = 0; VEC_iterate (gimple, SLP_TREE_SCALAR_STMTS (node), i, stmt); i++) + { + index = VEC_index (int, permutation, i); + VEC_replace (gimple, tmp_stmts, index, stmt); + } + + VEC_free (gimple, heap, SLP_TREE_SCALAR_STMTS (node)); + SLP_TREE_SCALAR_STMTS (node) = tmp_stmts; +} + + /* Check if the required load permutation is supported. LOAD_PERMUTATION contains a list of indices of the loads. In SLP this permutation is relative to the order of strided stores that are @@ -796,9 +850,11 @@ static bool vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, VEC (int, heap) *load_permutation) { - int i = 0, j, prev = -1, next, k; - bool supported; + int i = 0, j, prev = -1, next, k, number_of_groups; + bool supported, bad_permutation = false; sbitmap load_index; + slp_tree node; + gimple stmt; /* FORNOW: permutations are only supported in SLP. */ if (!slp_instn) @@ -811,9 +867,72 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, fprintf (vect_dump, "%d ", next); } + /* In case of reduction every load permutation is allowed, since the order + of the reduction statements is not important (as opposed to the case of + strided stores). The only condition we need to check is that all the + load nodes are of the same size and have the same permutation (and then + rearrange all the nodes of the SLP instance according to this + permutation). */ + + /* Check that all the load nodes are of the same size. */ + for (i = 0; + VEC_iterate (slp_tree, SLP_INSTANCE_LOADS (slp_instn), i, node); + i++) + if (VEC_length (gimple, SLP_TREE_SCALAR_STMTS (node)) + != (unsigned) group_size) + return false; + + node = SLP_INSTANCE_TREE (slp_instn); + stmt = VEC_index (gimple, SLP_TREE_SCALAR_STMTS (node), 0); + /* LOAD_PERMUTATION is a list of indices of all the loads of the SLP + instance, not all the loads belong to the same node or interleaving + group. Hence, we need to divide them into groups according to + GROUP_SIZE. */ + number_of_groups = VEC_length (int, load_permutation) / group_size; + + /* Reduction (there are no data-refs in the root). */ + if (!STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt))) + { + int first_group_load_index; + + /* Compare all the permutation sequences to the first one. */ + for (i = 1; i < number_of_groups; i++) + { + k = 0; + for (j = i * group_size; j < i * group_size + group_size; j++) + { + next = VEC_index (int, load_permutation, j); + first_group_load_index = VEC_index (int, load_permutation, k); + + if (next != first_group_load_index) + { + bad_permutation = true; + break; + } + + k++; + } + + if (bad_permutation) + break; + } + + if (!bad_permutation) + { + /* This permutaion is valid for reduction. Since the order of the + statements in the nodes is not important unless they are memory + accesses, we can rearrange the statements in all the nodes + according to the order of the loads. */ + vect_slp_rearrange_stmts (SLP_INSTANCE_TREE (slp_instn), group_size, + load_permutation); + VEC_free (int, heap, SLP_INSTANCE_LOAD_PERMUTATION (slp_instn)); + return true; + } + } + /* FORNOW: the only supported permutation is 0..01..1.. of length equal to GROUP_SIZE and where each sequence of same drs is of GROUP_SIZE length as - well. */ + well (unless it's reduction). */ if (VEC_length (int, load_permutation) != (unsigned int) (group_size * group_size)) return false; @@ -844,7 +963,11 @@ vect_supported_load_permutation_p (slp_instance slp_instn, int group_size, SET_BIT (load_index, prev); } - + + for (j = 0; j < group_size; j++) + if (!TEST_BIT (load_index, j)) + return false; + sbitmap_free (load_index); if (supported && i == group_size * group_size @@ -892,17 +1015,28 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, slp_tree node = XNEW (struct _slp_tree); unsigned int group_size = DR_GROUP_SIZE (vinfo_for_stmt (stmt)); unsigned int unrolling_factor = 1, nunits; - tree vectype, scalar_type; + tree vectype, scalar_type = NULL_TREE; gimple next; unsigned int vectorization_factor = 0; - int inside_cost = 0, outside_cost = 0, ncopies_for_cost; + int inside_cost = 0, outside_cost = 0, ncopies_for_cost, i; unsigned int max_nunits = 0; VEC (int, heap) *load_permutation; VEC (slp_tree, heap) *loads; + struct data_reference *dr = STMT_VINFO_DATA_REF (vinfo_for_stmt (stmt)); + + if (dr) + { + scalar_type = TREE_TYPE (DR_REF (dr)); + vectype = get_vectype_for_scalar_type (scalar_type); + group_size = DR_GROUP_SIZE (vinfo_for_stmt (stmt)); + } + else + { + gcc_assert (loop_vinfo); + vectype = STMT_VINFO_VECTYPE (vinfo_for_stmt (stmt)); + group_size = VEC_length (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo)); + } - scalar_type = TREE_TYPE (DR_REF (STMT_VINFO_DATA_REF ( - vinfo_for_stmt (stmt)))); - vectype = get_vectype_for_scalar_type (scalar_type); if (!vectype) { if (vect_print_dump_info (REPORT_SLP)) @@ -910,6 +1044,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, fprintf (vect_dump, "Build SLP failed: unsupported data-type "); print_generic_expr (vect_dump, scalar_type, TDF_SLIM); } + return false; } @@ -934,11 +1069,29 @@ vect_analyze_slp_instance (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo, /* Create a node (a root of the SLP tree) for the packed strided stores. */ SLP_TREE_SCALAR_STMTS (node) = VEC_alloc (gimple, heap, group_size); next = stmt; - /* Collect the stores and store them in SLP_TREE_SCALAR_STMTS. */ - while (next) + if (dr) { - VEC_safe_push (gimple, heap, SLP_TREE_SCALAR_STMTS (node), next); - next = DR_GROUP_NEXT_DR (vinfo_for_stmt (next)); + /* Collect the stores and store them in SLP_TREE_SCALAR_STMTS. */ + while (next) + { + VEC_safe_push (gimple, heap, SLP_TREE_SCALAR_STMTS (node), next); + next = DR_GROUP_NEXT_DR (vinfo_for_stmt (next)); + } + } + else + { + /* Collect reduction statements. */ + for (i = 0; VEC_iterate (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo), i, + next); + i++) + { + VEC_safe_push (gimple, heap, SLP_TREE_SCALAR_STMTS (node), next); + if (vect_print_dump_info (REPORT_DETAILS)) + { + fprintf (vect_dump, "pushing reduction into node: "); + print_gimple_stmt (vect_dump, next, 0, TDF_SLIM); + } + } } SLP_TREE_VEC_STMTS (node) = NULL; @@ -1031,7 +1184,7 @@ bool vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) { unsigned int i; - VEC (gimple, heap) *strided_stores; + VEC (gimple, heap) *strided_stores, *reductions = NULL; gimple store; bool ok = false; @@ -1039,10 +1192,14 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) fprintf (vect_dump, "=== vect_analyze_slp ==="); if (loop_vinfo) - strided_stores = LOOP_VINFO_STRIDED_STORES (loop_vinfo); + { + strided_stores = LOOP_VINFO_STRIDED_STORES (loop_vinfo); + reductions = LOOP_VINFO_REDUCTIONS (loop_vinfo); + } else strided_stores = BB_VINFO_STRIDED_STORES (bb_vinfo); + /* Find SLP sequences starting from groups of strided stores. */ for (i = 0; VEC_iterate (gimple, strided_stores, i, store); i++) if (vect_analyze_slp_instance (loop_vinfo, bb_vinfo, store)) ok = true; @@ -1055,6 +1212,12 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) return false; } + /* Find SLP sequences starting from groups of reductions. */ + if (loop_vinfo && VEC_length (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo)) > 1 + && vect_analyze_slp_instance (loop_vinfo, bb_vinfo, + VEC_index (gimple, reductions, 0))) + ok = true; + return true; } @@ -1116,7 +1279,10 @@ vect_detect_hybrid_slp_stmts (slp_tree node) if ((stmt_vinfo = vinfo_for_stmt (use_stmt)) && !STMT_SLP_TYPE (stmt_vinfo) && (STMT_VINFO_RELEVANT (stmt_vinfo) - || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_vinfo)))) + || VECTORIZABLE_CYCLE_DEF (STMT_VINFO_DEF_TYPE (stmt_vinfo))) + && !(gimple_code (use_stmt) == GIMPLE_PHI + && STMT_VINFO_DEF_TYPE (vinfo_for_stmt (use_stmt)) + == vect_reduction_def)) vect_mark_slp_stmts (node, hybrid, i); vect_detect_hybrid_slp_stmts (SLP_TREE_LEFT (node)); @@ -1425,11 +1591,14 @@ vect_update_slp_costs_according_to_vf (loop_vec_info loop_vinfo) /* For constant and loop invariant defs of SLP_NODE this function returns (vector) defs (VEC_OPRNDS) that will be used in the vectorized stmts. OP_NUM determines if we gather defs for operand 0 or operand 1 of the scalar - stmts. NUMBER_OF_VECTORS is the number of vector defs to create. */ + stmts. NUMBER_OF_VECTORS is the number of vector defs to create. + REDUC_INDEX is the index of the reduction operand in the statements, unless + it is -1. */ static void vect_get_constant_vectors (slp_tree slp_node, VEC(tree,heap) **vec_oprnds, - unsigned int op_num, unsigned int number_of_vectors) + unsigned int op_num, unsigned int number_of_vectors, + int reduc_index) { VEC (gimple, heap) *stmts = SLP_TREE_SCALAR_STMTS (slp_node); gimple stmt = VEC_index (gimple, stmts, 0); @@ -1445,6 +1614,50 @@ vect_get_constant_vectors (slp_tree slp_node, VEC(tree,heap) **vec_oprnds, int number_of_copies = 1; VEC (tree, heap) *voprnds = VEC_alloc (tree, heap, number_of_vectors); bool constant_p, is_store; + tree neutral_op = NULL; + + if (STMT_VINFO_DEF_TYPE (stmt_vinfo) == vect_reduction_def) + { + enum tree_code code = gimple_assign_rhs_code (stmt); + if (reduc_index == -1) + { + VEC_free (tree, heap, *vec_oprnds); + return; + } + + op_num = reduc_index - 1; + op = gimple_op (stmt, op_num + 1); + /* For additional copies (see the explanation of NUMBER_OF_COPIES below) + we need either neutral operands or the original operands. See + get_initial_def_for_reduction() for details. */ + switch (code) + { + case WIDEN_SUM_EXPR: + case DOT_PROD_EXPR: + case PLUS_EXPR: + case MINUS_EXPR: + case BIT_IOR_EXPR: + case BIT_XOR_EXPR: + if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (op))) + neutral_op = build_real (TREE_TYPE (op), dconst0); + else + neutral_op = build_int_cst (TREE_TYPE (op), 0); + + break; + + case MULT_EXPR: + case BIT_AND_EXPR: + if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (op))) + neutral_op = build_real (TREE_TYPE (op), dconst1); + else + neutral_op = build_int_cst (TREE_TYPE (op), 1); + + break; + + default: + neutral_op = NULL; + } + } if (STMT_VINFO_DATA_REF (stmt_vinfo)) { @@ -1495,6 +1708,19 @@ vect_get_constant_vectors (slp_tree slp_node, VEC(tree,heap) **vec_oprnds, else op = gimple_op (stmt, op_num + 1); + if (reduc_index != -1) + { + struct loop *loop = (gimple_bb (stmt))->loop_father; + gimple def_stmt = SSA_NAME_DEF_STMT (op); + + gcc_assert (loop); + /* Get the def before the loop. */ + op = PHI_ARG_DEF_FROM_EDGE (def_stmt, + loop_preheader_edge (loop)); + if (j != (number_of_copies - 1) && neutral_op) + op = neutral_op; + } + /* Create 'vect_ = {op0,op1,...,opn}'. */ t = tree_cons (NULL_TREE, op, t); @@ -1532,8 +1758,25 @@ vect_get_constant_vectors (slp_tree slp_node, VEC(tree,heap) **vec_oprnds, to replicate the vectors. */ while (number_of_vectors > VEC_length (tree, *vec_oprnds)) { - for (i = 0; VEC_iterate (tree, *vec_oprnds, i, vop) && i < vec_num; i++) - VEC_quick_push (tree, *vec_oprnds, vop); + tree neutral_vec = NULL; + + if (neutral_op) + { + if (!neutral_vec) + { + t = NULL; + for (i = 0; i < (unsigned) nunits; i++) + t = tree_cons (NULL_TREE, neutral_op, t); + neutral_vec = build_vector (vector_type, t); + } + + VEC_quick_push (tree, *vec_oprnds, neutral_vec); + } + else + { + for (i = 0; VEC_iterate (tree, *vec_oprnds, i, vop) && i < vec_num; i++) + VEC_quick_push (tree, *vec_oprnds, vop); + } } } @@ -1572,7 +1815,7 @@ vect_get_slp_vect_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds) void vect_get_slp_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds0, - VEC (tree,heap) **vec_oprnds1) + VEC (tree,heap) **vec_oprnds1, int reduc_index) { gimple first_stmt; enum tree_code code; @@ -1603,19 +1846,26 @@ vect_get_slp_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds0, *vec_oprnds0 = VEC_alloc (tree, heap, number_of_vects); /* SLP_NODE corresponds either to a group of stores or to a group of - unary/binary operations. We don't call this function for loads. */ - if (SLP_TREE_LEFT (slp_node)) + unary/binary operations. We don't call this function for loads. + For reduction defs we call vect_get_constant_vectors(), since we are + looking for initial loop invariant values. */ + if (SLP_TREE_LEFT (slp_node) && reduc_index == -1) /* The defs are already vectorized. */ vect_get_slp_vect_defs (SLP_TREE_LEFT (slp_node), vec_oprnds0); else /* Build vectors from scalar defs. */ - vect_get_constant_vectors (slp_node, vec_oprnds0, 0, number_of_vects); + vect_get_constant_vectors (slp_node, vec_oprnds0, 0, number_of_vects, + reduc_index); if (STMT_VINFO_DATA_REF (vinfo_for_stmt (first_stmt))) /* Since we don't call this function with loads, this is a group of stores. */ return; + /* For reductions, we only need initial values. */ + if (reduc_index != -1) + return; + code = gimple_assign_rhs_code (first_stmt); if (get_gimple_rhs_class (code) != GIMPLE_BINARY_RHS || !vec_oprnds1) return; @@ -1634,7 +1884,7 @@ vect_get_slp_defs (slp_tree slp_node, VEC (tree,heap) **vec_oprnds0, vect_get_slp_vect_defs (SLP_TREE_RIGHT (slp_node), vec_oprnds1); else /* Build vectors from scalar defs. */ - vect_get_constant_vectors (slp_node, vec_oprnds1, 1, number_of_vects); + vect_get_constant_vectors (slp_node, vec_oprnds1, 1, number_of_vects, -1); } @@ -2023,22 +2273,7 @@ vect_schedule_slp_instance (slp_tree node, slp_instance instance, si = gsi_for_stmt (stmt); is_store = vect_transform_stmt (stmt, &si, &strided_store, node, instance); - if (is_store) - { - if (DR_GROUP_FIRST_DR (stmt_info)) - /* If IS_STORE is TRUE, the vectorization of the - interleaving chain was completed - free all the stores in - the chain. */ - vect_remove_stores (DR_GROUP_FIRST_DR (stmt_info)); - else - /* FORNOW: SLP originates only from strided stores. */ - gcc_unreachable (); - - return true; - } - - /* FORNOW: SLP originates only from strided stores. */ - return false; + return is_store; } @@ -2071,6 +2306,26 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) fprintf (vect_dump, "vectorizing stmts using SLP."); } + for (i = 0; VEC_iterate (slp_instance, slp_instances, i, instance); i++) + { + slp_tree root = SLP_INSTANCE_TREE (instance); + gimple store; + unsigned int j; + gimple_stmt_iterator gsi; + + for (j = 0; VEC_iterate (gimple, SLP_TREE_SCALAR_STMTS (root), j, store) + && j < SLP_INSTANCE_GROUP_SIZE (instance); j++) + { + if (!STMT_VINFO_DATA_REF (vinfo_for_stmt (store))) + break; + + /* Free the attached stmt_vec_info and remove the stmt. */ + gsi = gsi_for_stmt (store); + gsi_remove (&gsi, true); + free_stmt_vec_info (store); + } + } + return is_store; } diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c index 4868f73e684..988749b792f 100644 --- a/gcc/tree-vect-stmts.c +++ b/gcc/tree-vect-stmts.c @@ -1134,7 +1134,7 @@ vect_get_vec_defs (tree op0, tree op1, gimple stmt, slp_tree slp_node) { if (slp_node) - vect_get_slp_defs (slp_node, vec_oprnds0, vec_oprnds1); + vect_get_slp_defs (slp_node, vec_oprnds0, vec_oprnds1, -1); else { tree vec_oprnd; @@ -2519,7 +2519,7 @@ vectorizable_type_demotion (gimple stmt, gimple_stmt_iterator *gsi, { /* Handle uses. */ if (slp_node) - vect_get_slp_defs (slp_node, &vec_oprnds0, NULL); + vect_get_slp_defs (slp_node, &vec_oprnds0, NULL, -1); else { VEC_free (tree, heap, vec_oprnds0); @@ -2819,7 +2819,7 @@ vectorizable_type_promotion (gimple stmt, gimple_stmt_iterator *gsi, if (j == 0) { if (slp_node) - vect_get_slp_defs (slp_node, &vec_oprnds0, &vec_oprnds1); + vect_get_slp_defs (slp_node, &vec_oprnds0, &vec_oprnds1, -1); else { vec_oprnd0 = vect_get_vec_def_for_operand (op0, stmt, NULL); @@ -3105,7 +3105,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, if (slp) { /* Get vectorized arguments for SLP_NODE. */ - vect_get_slp_defs (slp_node, &vec_oprnds, NULL); + vect_get_slp_defs (slp_node, &vec_oprnds, NULL, -1); vec_oprnd = VEC_index (tree, vec_oprnds, 0); } @@ -4049,7 +4049,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vectorize, slp_tree node) || vectorizable_load (stmt, NULL, NULL, NULL, NULL) || vectorizable_call (stmt, NULL, NULL) || vectorizable_store (stmt, NULL, NULL, NULL) - || vectorizable_reduction (stmt, NULL, NULL) + || vectorizable_reduction (stmt, NULL, NULL, NULL) || vectorizable_condition (stmt, NULL, NULL, NULL, 0)); else { @@ -4201,8 +4201,7 @@ vect_transform_stmt (gimple stmt, gimple_stmt_iterator *gsi, break; case reduc_vec_info_type: - gcc_assert (!slp_node); - done = vectorizable_reduction (stmt, gsi, &vec_stmt); + done = vectorizable_reduction (stmt, gsi, &vec_stmt, slp_node); gcc_assert (done); break; diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 52b2a7ec59f..bd43a4bc173 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -242,6 +242,9 @@ typedef struct _loop_vec_info { /* The unrolling factor needed to SLP the loop. In case of that pure SLP is applied to the loop, i.e., no unrolling is needed, this is 1. */ unsigned slp_unrolling_factor; + + /* Reduction cycles detected in the loop. Used in loop-aware SLP. */ + VEC (gimple, heap) *reductions; } *loop_vec_info; /* Access Functions. */ @@ -266,6 +269,7 @@ typedef struct _loop_vec_info { #define LOOP_VINFO_STRIDED_STORES(L) (L)->strided_stores #define LOOP_VINFO_SLP_INSTANCES(L) (L)->slp_instances #define LOOP_VINFO_SLP_UNROLLING_FACTOR(L) (L)->slp_unrolling_factor +#define LOOP_VINFO_REDUCTIONS(L) (L)->reductions #define LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT(L) \ VEC_length (gimple, (L)->may_misalign_stmts) > 0 @@ -844,7 +848,8 @@ extern void vect_transform_loop (loop_vec_info); extern loop_vec_info vect_analyze_loop_form (struct loop *); extern bool vectorizable_live_operation (gimple, gimple_stmt_iterator *, gimple *); -extern bool vectorizable_reduction (gimple, gimple_stmt_iterator *, gimple *); +extern bool vectorizable_reduction (gimple, gimple_stmt_iterator *, gimple *, + slp_tree); extern bool vectorizable_induction (gimple, gimple_stmt_iterator *, gimple *); extern int vect_estimate_min_profitable_iters (loop_vec_info); extern tree get_initial_def_for_reduction (gimple, tree, tree *); @@ -862,7 +867,7 @@ extern bool vect_analyze_slp (loop_vec_info, bb_vec_info); extern void vect_make_slp_decision (loop_vec_info); extern void vect_detect_hybrid_slp (loop_vec_info); extern void vect_get_slp_defs (slp_tree, VEC (tree,heap) **, - VEC (tree,heap) **); + VEC (tree,heap) **, int); extern LOC find_bb_location (basic_block); extern bb_vec_info vect_slp_analyze_bb (basic_block); extern void vect_slp_transform_bb (basic_block); diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 3b22948e39f..b23132ca043 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -3153,7 +3153,7 @@ static void adjust_range_with_scev (value_range_t *vr, struct loop *loop, gimple stmt, tree var) { - tree init, step, chrec, tmin, tmax, min, max, type; + tree init, step, chrec, tmin, tmax, min, max, type, tem; enum ev_direction dir; /* TODO. Don't adjust anti-ranges. An anti-range may provide @@ -3174,7 +3174,13 @@ adjust_range_with_scev (value_range_t *vr, struct loop *loop, return; init = initial_condition_in_loop_num (chrec, loop->num); + tem = op_with_constant_singleton_value_range (init); + if (tem) + init = tem; step = evolution_part_in_loop_num (chrec, loop->num); + tem = op_with_constant_singleton_value_range (step); + if (tem) + step = tem; /* If STEP is symbolic, we can't know whether INIT will be the minimum or maximum value in the range. Also, unless INIT is @@ -6432,7 +6438,18 @@ vrp_visit_phi_node (gimple phi) /* If the new range is different than the previous value, keep iterating. */ if (update_value_range (lhs, &vr_result)) - return SSA_PROP_INTERESTING; + { + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Found new range for "); + print_generic_expr (dump_file, lhs, 0); + fprintf (dump_file, ": "); + dump_value_range (dump_file, &vr_result); + fprintf (dump_file, "\n\n"); + } + + return SSA_PROP_INTERESTING; + } /* Nothing changed, don't add outgoing edges. */ return SSA_PROP_NOT_INTERESTING; diff --git a/gcc/tree.c b/gcc/tree.c index 6ac13186675..0eab137863b 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -8747,12 +8747,12 @@ make_or_reuse_accum_type (unsigned size, int unsignedp, int satp) this function to select one of the types as sizetype. */ void -build_common_tree_nodes (bool signed_char, bool signed_sizetype) +build_common_tree_nodes (bool signed_char) { error_mark_node = make_node (ERROR_MARK); TREE_TYPE (error_mark_node) = error_mark_node; - initialize_sizetypes (signed_sizetype); + initialize_sizetypes (); /* Define both `signed char' and `unsigned char'. */ signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE); diff --git a/gcc/tree.h b/gcc/tree.h index 648358ff8e6..8e063b0c630 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -457,6 +457,9 @@ struct GTY(()) tree_common { CALL_CANNOT_INLINE_P in CALL_EXPR + + ENUM_IS_SCOPED in + ENUMERAL_TYPE public_flag: @@ -501,6 +504,9 @@ struct GTY(()) tree_common { OMP_CLAUSE_PRIVATE_OUTER_REF in OMP_CLAUSE_PRIVATE + TYPE_REF_IS_RVALUE in + REFERENCE_TYPE + protected_flag: TREE_PROTECTED in @@ -1162,6 +1168,9 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, /* Used to mark a CALL_EXPR as not suitable for inlining. */ #define CALL_CANNOT_INLINE_P(NODE) (CALL_EXPR_CHECK (NODE)->base.static_flag) +/* Used to mark scoped enums. */ +#define ENUM_IS_SCOPED(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag) + /* In an expr node (usually a conversion) this means the node was made implicitly and should not lead to any sort of warning. In a decl node, warnings concerning the decl should be suppressed. This is used at @@ -1341,6 +1350,10 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, /* Used in classes in C++. */ #define TREE_PROTECTED(NODE) ((NODE)->base.protected_flag) +/* True if reference type NODE is a C++ rvalue reference. */ +#define TYPE_REF_IS_RVALUE(NODE) \ + (REFERENCE_TYPE_CHECK (NODE)->base.private_flag) + /* Nonzero in a _DECL if the use of the name is defined as a deprecated feature by __attribute__((deprecated)). */ #define TREE_DEPRECATED(NODE) \ @@ -3972,7 +3985,7 @@ extern tree make_unsigned_type (int); extern tree signed_or_unsigned_type_for (int, tree); extern tree signed_type_for (tree); extern tree unsigned_type_for (tree); -extern void initialize_sizetypes (bool); +extern void initialize_sizetypes (void); extern void set_sizetype (tree); extern void fixup_unsigned_type (tree); extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool); @@ -4986,7 +4999,7 @@ extern int real_onep (const_tree); extern int real_twop (const_tree); extern int real_minus_onep (const_tree); extern void init_ttree (void); -extern void build_common_tree_nodes (bool, bool); +extern void build_common_tree_nodes (bool); extern void build_common_tree_nodes_2 (int); extern void build_common_builtin_nodes (void); extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int); diff --git a/gcc/unwind-dw2-fde.c b/gcc/unwind-dw2-fde.c index 60535cfd780..93d427165c4 100644 --- a/gcc/unwind-dw2-fde.c +++ b/gcc/unwind-dw2-fde.c @@ -1,6 +1,6 @@ /* Subroutines needed for unwinding stack frames for exception handling. */ /* Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008, - 2009 Free Software Foundation, Inc. + 2009, 2010 Free Software Foundation, Inc. Contributed by Jason Merrill . This file is part of GCC. @@ -265,10 +265,18 @@ get_cie_encoding (const struct dwarf_cie *cie) _sleb128_t stmp; aug = cie->augmentation; + p = aug + strlen ((const char *)aug) + 1; /* Skip the augmentation string. */ + if (__builtin_expect (cie->version >= 4, 0)) + { + if (p[0] != sizeof (void *) || p[1] != 0) + return DW_EH_PE_omit; /* We are not prepared to handle unexpected + address sizes or segment selectors. */ + p += 2; /* Skip address size and segment size. */ + } + if (aug[0] != 'z') return DW_EH_PE_absptr; - p = aug + strlen ((const char *)aug) + 1; /* Skip the augmentation string. */ p = read_uleb128 (p, &utmp); /* Skip code alignment. */ p = read_sleb128 (p, &stmp); /* Skip data alignment. */ if (cie->version == 1) /* Skip return address column. */ @@ -614,6 +622,8 @@ classify_object_over_fdes (struct object *ob, const fde *this_fde) { last_cie = this_cie; encoding = get_cie_encoding (this_cie); + if (encoding == DW_EH_PE_omit) + return -1; base = base_from_object (encoding, ob); if (ob->s.b.encoding == DW_EH_PE_omit) ob->s.b.encoding = encoding; @@ -723,10 +733,26 @@ init_object (struct object* ob) { fde **p = ob->u.array; for (count = 0; *p; ++p) - count += classify_object_over_fdes (ob, *p); + { + size_t cur_count = classify_object_over_fdes (ob, *p); + if (cur_count == (size_t) -1) + goto unhandled_fdes; + count += cur_count; + } } else - count = classify_object_over_fdes (ob, ob->u.single); + { + count = classify_object_over_fdes (ob, ob->u.single); + if (count == (size_t) -1) + { + static const fde terminator; + unhandled_fdes: + ob->s.i = 0; + ob->s.b.encoding = DW_EH_PE_omit; + ob->u.single = &terminator; + return; + } + } /* The count field we have in the main struct object is somewhat limited, but should suffice for virtually all cases. If the diff --git a/gcc/unwind-dw2.c b/gcc/unwind-dw2.c index 3cf3189bb4f..65d639d4301 100644 --- a/gcc/unwind-dw2.c +++ b/gcc/unwind-dw2.c @@ -356,7 +356,16 @@ extract_cie_info (const struct dwarf_cie *cie, struct _Unwind_Context *context, aug += 2; } - /* Immediately following the augmentation are the code and + /* After the augmentation resp. pointer for "eh" augmentation + follows for CIE version >= 4 address size byte and + segment size byte. */ + if (__builtin_expect (cie->version >= 4, 0)) + { + if (p[0] != sizeof (void *) || p[1] != 0) + return NULL; + p += 2; + } + /* Immediately following this are the code and data alignment and return address column. */ p = read_uleb128 (p, &utmp); fs->code_align = (_Unwind_Word)utmp; diff --git a/gcc/varpool.c b/gcc/varpool.c index a13742d4957..40decfc867b 100644 --- a/gcc/varpool.c +++ b/gcc/varpool.c @@ -230,6 +230,12 @@ varpool_reset_queue (void) bool decide_is_variable_needed (struct varpool_node *node, tree decl) { + /* We do not track variable references at all and thus have no idea if the + variable was referenced in some other partition or not. + FIXME: We really need address taken edges in callgraph and varpool to + drive WPA and decide whether other partition might reference it or not. */ + if (flag_ltrans) + return true; /* If the user told us it is used, then it must be so. */ if ((node->externally_visible && !DECL_COMDAT (decl)) || node->force_output) diff --git a/include/ChangeLog b/include/ChangeLog index 938b5ba8440..5ba1afb33b9 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,7 @@ +2010-04-20 Nick Clifton + + * sha1.h: Update copyright notice to use GPLv3. + 2010-04-14 Doug Evans * filenames.h (HAS_DRIVE_SPEC, STRIP_DRIVE_SPEC): New macros. diff --git a/include/sha1.h b/include/sha1.h index 0c2b76557e4..5473f91f412 100644 --- a/include/sha1.h +++ b/include/sha1.h @@ -1,11 +1,11 @@ /* Declarations of functions and data types used for SHA1 sum library functions. - Copyright (C) 2000, 2001, 2003, 2005, 2006, 2008 + Copyright (C) 2000, 2001, 2003, 2005, 2006, 2008, 2010 Free Software Foundation, Inc. This program 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 2, or (at your option) any + Free Software Foundation; either version 3, or (at your option) any later version. This program is distributed in the hope that it will be useful, diff --git a/libcpp/po/ChangeLog b/libcpp/po/ChangeLog index 82730a42664..ba62d0fe34e 100644 --- a/libcpp/po/ChangeLog +++ b/libcpp/po/ChangeLog @@ -1,3 +1,11 @@ +2010-04-19 Joseph Myers + + * zh_CN.po: Update. + +2010-04-18 Joseph Myers + + * es.po: Update. + 2010-04-16 Joseph Myers * sv.po: Update. diff --git a/libcpp/po/es.po b/libcpp/po/es.po index 41c7a92bf59..b64345718c6 100644 --- a/libcpp/po/es.po +++ b/libcpp/po/es.po @@ -1,14 +1,14 @@ -# Mensajes en español para cpplib-4.5-b20100204 +# Mensajes en español para cpplib-4.5.0 # Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. # This file is distributed under the same license as the gcc package. # Cristian Othón Martínez Vera , 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010. # msgid "" msgstr "" -"Project-Id-Version: cpplib 4.5-b20100204\n" +"Project-Id-Version: cpplib 4.5.0\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" "POT-Creation-Date: 2010-04-06 14:10+0000\n" -"PO-Revision-Date: 2010-02-05 13:16-0600\n" +"PO-Revision-Date: 2010-04-18 03:46-0500\n" "Last-Translator: Cristian Othón Martínez Vera \n" "Language-Team: Spanish \n" "MIME-Version: 1.0\n" diff --git a/libcpp/po/zh_CN.po b/libcpp/po/zh_CN.po index 94accfb46bc..27e040480db 100644 --- a/libcpp/po/zh_CN.po +++ b/libcpp/po/zh_CN.po @@ -1,19 +1,21 @@ # Simplified Chinese translation for cpplib. # Copyright (C) 2005 Free Software Foundation, Inc. # This file is distributed under the same license as the gcc package. -# Meng Jie , 2005-2009. +# Meng Jie , 2005-2010. # msgid "" msgstr "" -"Project-Id-Version: cpplib 4.5-b20100204\n" +"Project-Id-Version: cpplib 4.5.0\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" "POT-Creation-Date: 2010-04-06 14:10+0000\n" -"PO-Revision-Date: 2010-02-23 15:53+0800\n" +"PO-Revision-Date: 2010-04-19 14:55+0800\n" "Last-Translator: Meng Jie \n" "Language-Team: Chinese (simplified) \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=utf-8\n" "Content-Transfer-Encoding: 8bit\n" +"X-Poedit-Language: Chinese\n" +"X-Poedit-Country: CHINA\n" #: charset.c:674 #, c-format diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index 5534cd6adaa..2b267e437a8 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,20 @@ +2010-04-21 Jakub Jelinek + + PR middle-end/43570 + * testsuite/libgomp.fortran/vla8.f90: New test. + +2010-04-20 Jakub Jelinek + + PR libgomp/43706 + * config/linux/affinity.c (gomp_init_affinity): Decrease + gomp_available_cpus if affinity mask confines the process to fewer + CPUs. + * config/linux/proc.c (get_num_procs): If gomp_cpu_affinity is + non-NULL, just return gomp_available_cpus. + + PR libgomp/43569 + * sections.c (gomp_sections_init): Initialize ws->mode. + 2010-04-14 Uros Bizjak * acinclude.m4 (LIBGOMP_CHECK_SYNC_BUILTINS): Remove set but diff --git a/libgomp/config/linux/affinity.c b/libgomp/config/linux/affinity.c index 40519e8896a..da9f3d8fdcb 100644 --- a/libgomp/config/linux/affinity.c +++ b/libgomp/config/linux/affinity.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Contributed by Jakub Jelinek . This file is part of the GNU OpenMP Library (libgomp). @@ -39,8 +39,9 @@ static unsigned int affinity_counter; void gomp_init_affinity (void) { - cpu_set_t cpuset; + cpu_set_t cpuset, cpusetnew; size_t idx, widx; + unsigned long cpus = 0; if (pthread_getaffinity_np (pthread_self (), sizeof (cpuset), &cpuset)) { @@ -51,10 +52,18 @@ gomp_init_affinity (void) return; } + CPU_ZERO (&cpusetnew); for (widx = idx = 0; idx < gomp_cpu_affinity_len; idx++) if (gomp_cpu_affinity[idx] < CPU_SETSIZE && CPU_ISSET (gomp_cpu_affinity[idx], &cpuset)) - gomp_cpu_affinity[widx++] = gomp_cpu_affinity[idx]; + { + if (! CPU_ISSET (gomp_cpu_affinity[idx], &cpusetnew)) + { + cpus++; + CPU_SET (gomp_cpu_affinity[idx], &cpusetnew); + } + gomp_cpu_affinity[widx++] = gomp_cpu_affinity[idx]; + } if (widx == 0) { @@ -66,6 +75,8 @@ gomp_init_affinity (void) } gomp_cpu_affinity_len = widx; + if (cpus < gomp_available_cpus) + gomp_available_cpus = cpus; CPU_ZERO (&cpuset); CPU_SET (gomp_cpu_affinity[0], &cpuset); pthread_setaffinity_np (pthread_self (), sizeof (cpuset), &cpuset); diff --git a/libgomp/config/linux/proc.c b/libgomp/config/linux/proc.c index dad6237e609..01f51dfa193 100644 --- a/libgomp/config/linux/proc.c +++ b/libgomp/config/linux/proc.c @@ -1,4 +1,5 @@ -/* Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. Contributed by Jakub Jelinek . This file is part of the GNU OpenMP Library (libgomp). @@ -104,26 +105,13 @@ get_num_procs (void) } else { - size_t idx; - static int affinity_cpus; - /* We can't use pthread_getaffinity_np in this case (we have changed it ourselves, it binds to just one CPU). Count instead the number of different CPUs we are - using. */ - CPU_ZERO (&cpuset); - if (affinity_cpus == 0) - { - int cpus = 0; - for (idx = 0; idx < gomp_cpu_affinity_len; idx++) - if (! CPU_ISSET (gomp_cpu_affinity[idx], &cpuset)) - { - cpus++; - CPU_SET (gomp_cpu_affinity[idx], &cpuset); - } - affinity_cpus = cpus; - } - return affinity_cpus; + using. gomp_init_affinity updated gomp_available_cpus to + the number of CPUs in the GOMP_AFFINITY mask that we are + allowed to use though. */ + return gomp_available_cpus; } #endif #ifdef _SC_NPROCESSORS_ONLN diff --git a/libgomp/sections.c b/libgomp/sections.c index 7acd441de53..c7f49b7c32a 100644 --- a/libgomp/sections.c +++ b/libgomp/sections.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc. +/* Copyright (C) 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Contributed by Richard Henderson . This file is part of the GNU OpenMP Library (libgomp). @@ -34,9 +34,25 @@ gomp_sections_init (struct gomp_work_share *ws, unsigned count) { ws->sched = GFS_DYNAMIC; ws->chunk_size = 1; - ws->end = count + 1; + ws->end = count + 1L; ws->incr = 1; ws->next = 1; +#ifdef HAVE_SYNC_BUILTINS + /* Prepare things to make each iteration faster. */ + if (sizeof (long) > sizeof (unsigned)) + ws->mode = 1; + else + { + struct gomp_thread *thr = gomp_thread (); + struct gomp_team *team = thr->ts.team; + long nthreads = team ? team->nthreads : 1; + + ws->mode = ((nthreads | ws->end) + < 1UL << (sizeof (long) * __CHAR_BIT__ / 2 - 1)); + } +#else + ws->mode = 0; +#endif } /* This routine is called when first encountering a sections construct diff --git a/libgomp/testsuite/libgomp.fortran/vla8.f90 b/libgomp/testsuite/libgomp.fortran/vla8.f90 new file mode 100644 index 00000000000..f66fe84a375 --- /dev/null +++ b/libgomp/testsuite/libgomp.fortran/vla8.f90 @@ -0,0 +1,254 @@ +! { dg-do run } + + call test +contains + subroutine check (x, y, l) + integer :: x, y + logical :: l + l = l .or. x .ne. y + end subroutine check + + subroutine foo (c, d, e, f, g, h, i, j, k, n) + use omp_lib + integer :: n + character (len = *) :: c + character (len = n) :: d + integer, dimension (2, 3:5, n) :: e + integer, dimension (2, 3:n, n) :: f + character (len = *), dimension (5, 3:n) :: g + character (len = n), dimension (5, 3:n) :: h + real, dimension (:, :, :) :: i + double precision, dimension (3:, 5:, 7:) :: j + integer, dimension (:, :, :) :: k + logical :: l + integer :: p, q, r + character (len = n) :: s + integer, dimension (2, 3:5, n) :: t + integer, dimension (2, 3:n, n) :: u + character (len = n), dimension (5, 3:n) :: v + character (len = 2 * n + 24) :: w + integer :: x, z + character (len = 1) :: y + l = .false. +!$omp parallel default (none) private (c, d, e, f, g, h, i, j, k) & +!$omp & private (s, t, u, v) reduction (.or.:l) num_threads (6) & +!$omp private (p, q, r, w, x, y) shared (z) + x = omp_get_thread_num () + w = '' + if (x .eq. 0) w = 'thread0thr_number_0THREAD0THR_NUMBER_0' + if (x .eq. 1) w = 'thread1thr_number_1THREAD1THR_NUMBER_1' + if (x .eq. 2) w = 'thread2thr_number_2THREAD2THR_NUMBER_2' + if (x .eq. 3) w = 'thread3thr_number_3THREAD3THR_NUMBER_3' + if (x .eq. 4) w = 'thread4thr_number_4THREAD4THR_NUMBER_4' + if (x .eq. 5) w = 'thread5thr_number_5THREAD5THR_NUMBER_5' + c = w(8:19) + d = w(1:7) + forall (p = 1:2, q = 3:5, r = 1:7) e(p, q, r) = 5 * x + p + q + 2 * r + forall (p = 1:2, q = 3:7, r = 1:7) f(p, q, r) = 25 * x + p + q + 2 * r + forall (p = 1:5, q = 3:7, p + q .le. 8) g(p, q) = w(8:19) + forall (p = 1:5, q = 3:7, p + q .gt. 8) g(p, q) = w(27:38) + forall (p = 1:5, q = 3:7, p + q .le. 8) h(p, q) = w(1:7) + forall (p = 1:5, q = 3:7, p + q .gt. 8) h(p, q) = w(20:26) + forall (p = 3:5, q = 2:6, r = 1:7) i(p - 2, q - 1, r) = (7.5 + x) * p * q * r + forall (p = 3:5, q = 2:6, r = 1:7) j(p, q + 3, r + 6) = (9.5 + x) * p * q * r + forall (p = 1:5, q = 7:7, r = 4:6) k(p, q - 6, r - 3) = 19 + x + p + q + 3 * r + s = w(20:26) + forall (p = 1:2, q = 3:5, r = 1:7) t(p, q, r) = -10 + x + p - q + 2 * r + forall (p = 1:2, q = 3:7, r = 1:7) u(p, q, r) = 30 - x - p + q - 2 * r + forall (p = 1:5, q = 3:7, p + q .le. 8) v(p, q) = w(1:7) + forall (p = 1:5, q = 3:7, p + q .gt. 8) v(p, q) = w(20:26) +!$omp barrier + y = '' + if (x .eq. 0) y = '0' + if (x .eq. 1) y = '1' + if (x .eq. 2) y = '2' + if (x .eq. 3) y = '3' + if (x .eq. 4) y = '4' + if (x .eq. 5) y = '5' + l = l .or. w(7:7) .ne. y + l = l .or. w(19:19) .ne. y + l = l .or. w(26:26) .ne. y + l = l .or. w(38:38) .ne. y + l = l .or. c .ne. w(8:19) + l = l .or. d .ne. w(1:7) + l = l .or. s .ne. w(20:26) + do 103, p = 1, 2 + do 103, q = 3, 7 + do 103, r = 1, 7 + if (q .lt. 6) l = l .or. e(p, q, r) .ne. 5 * x + p + q + 2 * r + l = l .or. f(p, q, r) .ne. 25 * x + p + q + 2 * r + if (r .lt. 6 .and. q + r .le. 8) l = l .or. g(r, q) .ne. w(8:19) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. g(r, q) .ne. w(27:38) + if (r .lt. 6 .and. q + r .le. 8) l = l .or. h(r, q) .ne. w(1:7) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. h(r, q) .ne. w(20:26) + if (q .lt. 6) l = l .or. t(p, q, r) .ne. -10 + x + p - q + 2 * r + l = l .or. u(p, q, r) .ne. 30 - x - p + q - 2 * r + if (r .lt. 6 .and. q + r .le. 8) l = l .or. v(r, q) .ne. w(1:7) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. v(r, q) .ne. w(20:26) +103 continue + do 104, p = 3, 5 + do 104, q = 2, 6 + do 104, r = 1, 7 + l = l .or. i(p - 2, q - 1, r) .ne. (7.5 + x) * p * q * r + l = l .or. j(p, q + 3, r + 6) .ne. (9.5 + x) * p * q * r +104 continue + do 105, p = 1, 5 + do 105, q = 4, 6 + l = l .or. k(p, 1, q - 3) .ne. 19 + x + p + 7 + 3 * q +105 continue + call check (size (e, 1), 2, l) + call check (size (e, 2), 3, l) + call check (size (e, 3), 7, l) + call check (size (e), 42, l) + call check (size (f, 1), 2, l) + call check (size (f, 2), 5, l) + call check (size (f, 3), 7, l) + call check (size (f), 70, l) + call check (size (g, 1), 5, l) + call check (size (g, 2), 5, l) + call check (size (g), 25, l) + call check (size (h, 1), 5, l) + call check (size (h, 2), 5, l) + call check (size (h), 25, l) + call check (size (i, 1), 3, l) + call check (size (i, 2), 5, l) + call check (size (i, 3), 7, l) + call check (size (i), 105, l) + call check (size (j, 1), 4, l) + call check (size (j, 2), 5, l) + call check (size (j, 3), 7, l) + call check (size (j), 140, l) + call check (size (k, 1), 5, l) + call check (size (k, 2), 1, l) + call check (size (k, 3), 3, l) + call check (size (k), 15, l) +!$omp single + z = omp_get_thread_num () +!$omp end single copyprivate (c, d, e, f, g, h, i, j, k, s, t, u, v) + w = '' + x = z + if (x .eq. 0) w = 'thread0thr_number_0THREAD0THR_NUMBER_0' + if (x .eq. 1) w = 'thread1thr_number_1THREAD1THR_NUMBER_1' + if (x .eq. 2) w = 'thread2thr_number_2THREAD2THR_NUMBER_2' + if (x .eq. 3) w = 'thread3thr_number_3THREAD3THR_NUMBER_3' + if (x .eq. 4) w = 'thread4thr_number_4THREAD4THR_NUMBER_4' + if (x .eq. 5) w = 'thread5thr_number_5THREAD5THR_NUMBER_5' + y = '' + if (x .eq. 0) y = '0' + if (x .eq. 1) y = '1' + if (x .eq. 2) y = '2' + if (x .eq. 3) y = '3' + if (x .eq. 4) y = '4' + if (x .eq. 5) y = '5' + l = l .or. w(7:7) .ne. y + l = l .or. w(19:19) .ne. y + l = l .or. w(26:26) .ne. y + l = l .or. w(38:38) .ne. y + l = l .or. c .ne. w(8:19) + l = l .or. d .ne. w(1:7) + l = l .or. s .ne. w(20:26) + do 113, p = 1, 2 + do 113, q = 3, 7 + do 113, r = 1, 7 + if (q .lt. 6) l = l .or. e(p, q, r) .ne. 5 * x + p + q + 2 * r + l = l .or. f(p, q, r) .ne. 25 * x + p + q + 2 * r + if (r .lt. 6 .and. q + r .le. 8) l = l .or. g(r, q) .ne. w(8:19) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. g(r, q) .ne. w(27:38) + if (r .lt. 6 .and. q + r .le. 8) l = l .or. h(r, q) .ne. w(1:7) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. h(r, q) .ne. w(20:26) + if (q .lt. 6) l = l .or. t(p, q, r) .ne. -10 + x + p - q + 2 * r + l = l .or. u(p, q, r) .ne. 30 - x - p + q - 2 * r + if (r .lt. 6 .and. q + r .le. 8) l = l .or. v(r, q) .ne. w(1:7) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. v(r, q) .ne. w(20:26) +113 continue + do 114, p = 3, 5 + do 114, q = 2, 6 + do 114, r = 1, 7 + l = l .or. i(p - 2, q - 1, r) .ne. (7.5 + x) * p * q * r + l = l .or. j(p, q + 3, r + 6) .ne. (9.5 + x) * p * q * r +114 continue + do 115, p = 1, 5 + do 115, q = 4, 6 + l = l .or. k(p, 1, q - 3) .ne. 19 + x + p + 7 + 3 * q +115 continue + x = omp_get_thread_num () + w = '' + if (x .eq. 0) w = 'thread0thr_number_0THREAD0THR_NUMBER_0' + if (x .eq. 1) w = 'thread1thr_number_1THREAD1THR_NUMBER_1' + if (x .eq. 2) w = 'thread2thr_number_2THREAD2THR_NUMBER_2' + if (x .eq. 3) w = 'thread3thr_number_3THREAD3THR_NUMBER_3' + if (x .eq. 4) w = 'thread4thr_number_4THREAD4THR_NUMBER_4' + if (x .eq. 5) w = 'thread5thr_number_5THREAD5THR_NUMBER_5' + c = w(8:19) + d = w(1:7) + forall (p = 1:2, q = 3:5, r = 1:7) e(p, q, r) = 5 * x + p + q + 2 * r + forall (p = 1:2, q = 3:7, r = 1:7) f(p, q, r) = 25 * x + p + q + 2 * r + forall (p = 1:5, q = 3:7, p + q .le. 8) g(p, q) = w(8:19) + forall (p = 1:5, q = 3:7, p + q .gt. 8) g(p, q) = w(27:38) + forall (p = 1:5, q = 3:7, p + q .le. 8) h(p, q) = w(1:7) + forall (p = 1:5, q = 3:7, p + q .gt. 8) h(p, q) = w(20:26) + forall (p = 3:5, q = 2:6, r = 1:7) i(p - 2, q - 1, r) = (7.5 + x) * p * q * r + forall (p = 3:5, q = 2:6, r = 1:7) j(p, q + 3, r + 6) = (9.5 + x) * p * q * r + forall (p = 1:5, q = 7:7, r = 4:6) k(p, q - 6, r - 3) = 19 + x + p + q + 3 * r + s = w(20:26) + forall (p = 1:2, q = 3:5, r = 1:7) t(p, q, r) = -10 + x + p - q + 2 * r + forall (p = 1:2, q = 3:7, r = 1:7) u(p, q, r) = 30 - x - p + q - 2 * r + forall (p = 1:5, q = 3:7, p + q .le. 8) v(p, q) = w(1:7) + forall (p = 1:5, q = 3:7, p + q .gt. 8) v(p, q) = w(20:26) +!$omp barrier + y = '' + if (x .eq. 0) y = '0' + if (x .eq. 1) y = '1' + if (x .eq. 2) y = '2' + if (x .eq. 3) y = '3' + if (x .eq. 4) y = '4' + if (x .eq. 5) y = '5' + l = l .or. w(7:7) .ne. y + l = l .or. w(19:19) .ne. y + l = l .or. w(26:26) .ne. y + l = l .or. w(38:38) .ne. y + l = l .or. c .ne. w(8:19) + l = l .or. d .ne. w(1:7) + l = l .or. s .ne. w(20:26) + do 123, p = 1, 2 + do 123, q = 3, 7 + do 123, r = 1, 7 + if (q .lt. 6) l = l .or. e(p, q, r) .ne. 5 * x + p + q + 2 * r + l = l .or. f(p, q, r) .ne. 25 * x + p + q + 2 * r + if (r .lt. 6 .and. q + r .le. 8) l = l .or. g(r, q) .ne. w(8:19) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. g(r, q) .ne. w(27:38) + if (r .lt. 6 .and. q + r .le. 8) l = l .or. h(r, q) .ne. w(1:7) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. h(r, q) .ne. w(20:26) + if (q .lt. 6) l = l .or. t(p, q, r) .ne. -10 + x + p - q + 2 * r + l = l .or. u(p, q, r) .ne. 30 - x - p + q - 2 * r + if (r .lt. 6 .and. q + r .le. 8) l = l .or. v(r, q) .ne. w(1:7) + if (r .lt. 6 .and. q + r .gt. 8) l = l .or. v(r, q) .ne. w(20:26) +123 continue + do 124, p = 3, 5 + do 124, q = 2, 6 + do 124, r = 1, 7 + l = l .or. i(p - 2, q - 1, r) .ne. (7.5 + x) * p * q * r + l = l .or. j(p, q + 3, r + 6) .ne. (9.5 + x) * p * q * r +124 continue + do 125, p = 1, 5 + do 125, q = 4, 6 + l = l .or. k(p, 1, q - 3) .ne. 19 + x + p + 7 + 3 * q +125 continue +!$omp end parallel + if (l) call abort + end subroutine foo + + subroutine test + character (len = 12) :: c + character (len = 7) :: d + integer, dimension (2, 3:5, 7) :: e + integer, dimension (2, 3:7, 7) :: f + character (len = 12), dimension (5, 3:7) :: g + character (len = 7), dimension (5, 3:7) :: h + real, dimension (3:5, 2:6, 1:7) :: i + double precision, dimension (3:6, 2:6, 1:7) :: j + integer, dimension (1:5, 7:7, 4:6) :: k + integer :: p, q, r + call foo (c, d, e, f, g, h, i, j, k, 7) + end subroutine test +end diff --git a/libjava/ChangeLog b/libjava/ChangeLog index dd502d13c09..c986d1092c7 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,8 @@ +2010-04-19 Andrew Haley + + PR libgcj/40860 + * configure.ac: Handle --no-merge-exidx-entries. + 2010-04-07 Jakub Jelinek * exception.cc (_Jv_Throw): Avoid set but not used warning. diff --git a/libjava/configure b/libjava/configure index ca3329d3944..6be8109031a 100755 --- a/libjava/configure +++ b/libjava/configure @@ -20520,6 +20520,39 @@ arm*linux*eabi) ;; esac +# Check for --no-merge-exidx-entries, an ARM-specific linker option. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for --no-merge-exidx-entries" >&5 +$as_echo_n "checking for --no-merge-exidx-entries... " >&6; } +if test "${libgcj_cv_exidx+set}" = set; then : + $as_echo_n "(cached) " >&6 +else + saved_ldflags="$LDFLAGS" + LDFLAGS="${LDFLAGS} -Wl,--no-merge-exidx-entries" + if test x$gcc_no_link = xyes; then + as_fn_error "Link tests are not allowed after GCC_NO_EXECUTABLES." "$LINENO" 5 +fi +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +int main(void){ return 0;} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + eval "libgcj_cv_exidx=yes" +else + eval "libgcj_cv_exidx=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS="${saved_ldflags}" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libgcj_cv_exidx" >&5 +$as_echo "$libgcj_cv_exidx" >&6; } +if test "${libgcj_cv_exidx}" = "yes"; then + SYSTEMSPEC="${SYSTEMSPEC} --no-merge-exidx-entries" + extra_ldflags="${extra_ldflags} -Wl,--no-merge-exidx-entries" +fi + + diff --git a/libjava/configure.ac b/libjava/configure.ac index 255fb64595e..7f4befa830b 100644 --- a/libjava/configure.ac +++ b/libjava/configure.ac @@ -927,6 +927,21 @@ arm*linux*eabi) extra_ldflags_libjava=-liconv ;; esac + +# Check for --no-merge-exidx-entries, an ARM-specific linker option. +AC_CACHE_CHECK([for --no-merge-exidx-entries], [libgcj_cv_exidx], + [saved_ldflags="$LDFLAGS" + LDFLAGS="${LDFLAGS} -Wl,--no-merge-exidx-entries" + AC_LINK_IFELSE([int main(void){ return 0;} ], + [eval "libgcj_cv_exidx=yes"], + [eval "libgcj_cv_exidx=no"]) + LDFLAGS="${saved_ldflags}"] +) +if test "${libgcj_cv_exidx}" = "yes"; then + SYSTEMSPEC="${SYSTEMSPEC} --no-merge-exidx-entries" + extra_ldflags="${extra_ldflags} -Wl,--no-merge-exidx-entries" +fi + AC_SUBST(extra_ldflags_libjava) AC_SUBST(extra_ldflags) AC_SUBST(LIBSTDCXXSPEC) diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index d34b55a8362..96d166fa225 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,20 @@ +2010-04-22 Johannes Singler + + * include/parallel/partition.h (__parallel_partition): + Improve scalability by: + -introducing new variables __leftold, __rightold, __dist, thus + -getting rid of omp lock by using atomic operations + -getting rid of two omp barriers + +2010-04-22 Jonathan Wakely + + * doc/xml/faq.xml: Link to manual. + * doc/xml/manual/using.xml: Expand dynamic libraries section. + * doc/xml/manual/strings.xml: Mention shrink_to_fit() member. + * doc/xml/manual/prerequisites.xml: Link to doxygen requirements. + * doc/xml/manual/appendix_contributing.xml: Update Bash version. + * doc/html/*: Regenerate. + 2010-04-13 Ian Lance Taylor * include/backward/hash_map: Don't #include "backward_warning.h" diff --git a/libstdc++-v3/doc/html/api.html b/libstdc++-v3/doc/html/api.html index 61ddda971a2..5a40764298d 100644 --- a/libstdc++-v3/doc/html/api.html +++ b/libstdc++-v3/doc/html/api.html @@ -1,24 +1,25 @@ -API and Source Level Documentation
API and Source Level Documentation
Prev  Next

API and Source Level Documentation

Copyright © +API Documentation

API Documentation
Prev  Next

API Documentation

Copyright © 2008 + , + 2010 FSF -

-The GNU C++ library sources have been specially formatted so that with the -proper invocation of another tool (Doxygen), a set of HTML pages -are generated from the sources files themselves. The resultant -documentation is referred to as Source Level Documentation, and is -useful for examining the signatures of public member functions for -the library classes, finding out what is in a particular include -file, looking at inheritance diagrams, etc. + The GNU C++ library sources have been specially formatted so that + with the proper invocation of another tool (Doxygen), a set of + indexed reference material can generated from the sources files + themselves. The resultant documentation is referred to as the API + documentation, and is useful for examining the signatures of public + member functions for the library classes, finding out what is in a + particular include file, looking at inheritance diagrams, etc.

-The source-level documentation for the most recent releases can be -viewed online: + The API documentation, rendered into HTML, can be viewed online:

  • for the 3.4 release @@ -39,16 +40,14 @@ viewed online: (For the main development tree; see the date on the first page.)

-This generated HTML collection, as above, is also available for download in the libstdc++ snapshots directory at + The rendered HTML, as above, is also available for download on the + gcc.org site in a directory located at <URL:ftp://gcc.gnu.org/pub/gcc/libstdc++/doxygen/>. You will almost certainly need to use one of the mirror sites to download - the tarball. After unpacking, simply load libstdc++-html-*/index.html + the tarball. After unpacking, simply load libstdc++-html-*/index.html into a browser.

-Documentation for older releases is available for download only, not -online viewing. -

-In addition, an initial set of man pages are also available in the -same place as the HTML collections. Start with C++Intro(3). + In addition, a rendered set of man pages are available in the same + location specified above. Start with C++Intro(3).

Prev Up Next
 Home 
diff --git a/libstdc++-v3/doc/html/bk02.html b/libstdc++-v3/doc/html/bk02.html dissimilarity index 65% index f0dbebb2ac4..16ac5f094f6 100644 --- a/libstdc++-v3/doc/html/bk02.html +++ b/libstdc++-v3/doc/html/bk02.html @@ -1,3 +1,3 @@ - - -
Prev   Next

Table of Contents

API and Source Level Documentation
Prev   Next
Backwards Compatibility Home API and Source Level Documentation
+ + +
Prev   Next

Table of Contents

API Documentation
Prev   Next
Backwards Compatibility Home API Documentation
diff --git a/libstdc++-v3/doc/html/bk03.html b/libstdc++-v3/doc/html/bk03.html dissimilarity index 68% index bc43c8d07bb..89beabfeb26 100644 --- a/libstdc++-v3/doc/html/bk03.html +++ b/libstdc++-v3/doc/html/bk03.html @@ -1,3 +1,3 @@ - - -
Prev   Next

Table of Contents

Frequently Asked Questions
Prev   Next
API and Source Level Documentation Home Frequently Asked Questions
+ + +
Prev   Next

Table of Contents

Frequently Asked Questions
Prev   Next
API Documentation Home Frequently Asked Questions
diff --git a/libstdc++-v3/doc/html/faq.html b/libstdc++-v3/doc/html/faq.html index 31ba54106aa..046cbb3bc83 100644 --- a/libstdc++-v3/doc/html/faq.html +++ b/libstdc++-v3/doc/html/faq.html @@ -4,7 +4,7 @@ 2008 FSF -

1. General Information
1.1. +

1. General Information
1.1. What is libstdc++?
1.2. Why should I use libstdc++? @@ -315,12 +315,15 @@ and ldconfig for more information. The dynamic linker has different names on different platforms but the man page is usually called something such as ld.so/rtld/dld.so. +

+ Using LD_LIBRARY_PATH is not always the best solution, Finding Dynamic or Shared + Libraries in the manual gives some alternatives.

3.5.

What's libsupc++?

If the only functions from libstdc++.a which you need are language support functions (those listed in - clause 18 of the + clause 18 of the standard, e.g., new and delete), then try linking against libsupc++.a, which is a subset of @@ -647,8 +650,9 @@ typo, or wrong visibility, or you just plain forgot, etc).

More information, including how to optionally enable/disable the - checks, is available - here. + checks, is available in the + Diagnostics. + chapter of the manual.

6.6.

Program crashes when using library code in a dynamically-loaded library @@ -685,7 +689,7 @@ list::size() is O(n)!

See - the Containers + the Containers chapter.

6.9.

Aw, that's easy to fix! @@ -869,6 +873,6 @@     

The copy will take O(n) time and the swap is constant time.

- See Shrink-to-fit + See Shrink-to-fit strings for a similar solution for strings.

Prev Up 
 Home 
diff --git a/libstdc++-v3/doc/html/manual/abi.html b/libstdc++-v3/doc/html/manual/abi.html index 25d0a568ee6..618da46367b 100644 --- a/libstdc++-v3/doc/html/manual/abi.html +++ b/libstdc++-v3/doc/html/manual/abi.html @@ -8,12 +8,12 @@ C++ applications often dependent on specific language support routines, say for throwing exceptions, or catching exceptions, and perhaps also dependent on features in the C++ Standard Library. -

+

The C++ Standard Library has many include files, types defined in those include files, specific named functions, and other behavior. The text of these behaviors, as written in source include files, is called the Application Programing Interface, or API. -

+

Furthermore, C++ source that is compiled into object files is transformed by the compiler: it arranges objects with specific alignment and in a particular layout, mangling names according to a @@ -32,7 +32,7 @@ -fno-exceptions, but include others: see the complete list in the GCC manual under the heading Options for Code Generation Conventions. -

+

The configure options used when building a specific libstdc++ version may also impact the resulting library ABI. The available configure options, and their impact on the library ABI, are @@ -240,11 +240,11 @@ int main() %g++ hello.cc -o hello.out %ldd hello.out - libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x00764000) - libm.so.6 => /lib/tls/libm.so.6 (0x004a8000) - libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x40016000) - libc.so.6 => /lib/tls/libc.so.6 (0x0036d000) - /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000) + libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x00764000) + libm.so.6 => /lib/tls/libm.so.6 (0x004a8000) + libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x40016000) + libc.so.6 => /lib/tls/libc.so.6 (0x0036d000) + /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000) %nm hello.out

@@ -273,7 +273,7 @@ class that would otherwise have implicit versions. This will change the way the compiler deals with this class in by-value return statements or parameters: instead of being passing instances of this class in registers, the compiler will be forced to use memory. See this part - of the C++ ABI documentation for further details. + of the C++ ABI documentation for further details.

Implementation

  1. Separation of interface and implementation

    @@ -298,7 +298,7 @@ class in registers, the compiler will be forced to use memory. See wchar_t instantiations, and includes basic_string, the locale facets, and the types in iostreams. -

+

In addition, these techniques have the additional benefit that they reduce binary size, which can increase runtime performance.

  • @@ -329,7 +329,7 @@ standard includes.

    • <

    Testing the C++ compiler ABI can be done various ways.

    - One. Intel ABI checker. + One. Intel ABI checker.

    Two. The second is yet unreleased, but has been announced on the gcc @@ -344,16 +344,16 @@ discussed on the gcc mailing lists.

    Testing the C++ library ABI can also be done various ways.

    -One. -(Brendan Kehoe, Jeff Law suggestion to run 'make check-c++' two ways, +One. +(Brendan Kehoe, Jeff Law suggestion to run 'make check-c++' two ways, one with a new compiler and an old library, and the other with an old compiler and a new library, and look for testsuite regressions)

    Details on how to set this kind of test up can be found here: http://gcc.gnu.org/ml/gcc/2002-08/msg00142.html

    -Two. -Use the 'make check-abi' rule in the libstdc++ Makefile. +Two. +Use the 'make check-abi' rule in the libstdc++ Makefile.

    This is a proactive check the library ABI. Currently, exported symbol names that are either weak or defined are checked against a last known @@ -372,7 +372,7 @@ machinery.

    This dataset is insufficient, yet a start. Also needed is a comprehensive check for all user-visible types part of the standard -library for sizeof() and alignof() changes. +library for sizeof() and alignof() changes.

    Verifying compatible layouts of objects is not even attempted. It should be possible to use sizeof, alignof, and offsetof to compute @@ -403,7 +403,7 @@ exceptions, locale, etc. %$bld/H-x86-gcc-3.4.0/bin/g++ -c a.cc -%ar cru libone.a a.o +%ar cru libone.a a.o

    And, libtwo is constructed as follows: 

     %$bld/H-x86-gcc-3.3.3/bin/g++ -fPIC -DPIC -c b.cc
 
@@ -413,24 +413,24 @@ exceptions, locale, etc.
 
 %$bld/H-x86-gcc-3.3.3/bin/g++ -c b.cc
 
-%ar cru libtwo.a b.o 
+%ar cru libtwo.a b.o

    ...with the resulting libraries looking like 

     
 %ldd libone.so.1.0.0
-        libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x40016000)
-        libm.so.6 => /lib/tls/libm.so.6 (0x400fa000)
-        libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x4011c000)
-        libc.so.6 => /lib/tls/libc.so.6 (0x40125000)
-        /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000)
+	libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x40016000)
+	libm.so.6 => /lib/tls/libm.so.6 (0x400fa000)
+	libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x4011c000)
+	libc.so.6 => /lib/tls/libc.so.6 (0x40125000)
+	/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000)
 
 %ldd libtwo.so.1.0.0
-        libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x40027000)
-        libm.so.6 => /lib/tls/libm.so.6 (0x400e1000)
-        libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x40103000)
-        libc.so.6 => /lib/tls/libc.so.6 (0x4010c000)
-        /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000)
+	libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x40027000)
+	libm.so.6 => /lib/tls/libm.so.6 (0x400e1000)
+	libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x40103000)
+	libc.so.6 => /lib/tls/libc.so.6 (0x4010c000)
+	/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000)
 
-

    +

    Then, the "C" compiler is used to compile a source file that uses functions from each library. 

    @@ -440,18 +440,18 @@ gcc test.c -g -O2 -L. -lone -ltwo /usr/lib/libstdc++.so.5 /usr/lib/libstdc++.so.
 
     
 %ldd a.out
-        libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x00764000)
-        libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x40015000)
-        libc.so.6 => /lib/tls/libc.so.6 (0x0036d000)
-        libm.so.6 => /lib/tls/libm.so.6 (0x004a8000)
-        libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x400e5000)
-        /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000)
+	libstdc++.so.5 => /usr/lib/libstdc++.so.5 (0x00764000)
+	libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x40015000)
+	libc.so.6 => /lib/tls/libc.so.6 (0x0036d000)
+	libm.so.6 => /lib/tls/libm.so.6 (0x004a8000)
+	libgcc_s.so.1 => /mnt/hd/bld/gcc/gcc/libgcc_s.so.1 (0x400e5000)
+	/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x00355000)
 
 
    
   This resulting binary, when executed, will be able to safely use
   code from both liba, and the dependent libstdc++.so.6, and libb,
   with the dependent libstdc++.so.5.
-

    Outstanding Issues

    +

    Outstanding Issues

    Some features in the C++ language make versioning especially difficult. In particular, compiler generated constructs such as implicit instantiations for templates, typeinfo information, and @@ -464,60 +464,71 @@ gcc test.c -g -O2 -L. -lone -ltwo /usr/lib/libstdc++.so.5 /usr/lib/libstdc++.so. 24660: versioning weak symbols in libstdc++

    19664: libstdc++ headers should have pop/push of the visibility around the declarations -

    Bibliography

    - ABIcheck, a vague idea of checking ABI compatibility - . +

    Bibliography

    + + ABIcheck, a vague idea of checking ABI compatibility + - .

    - C++ ABI Reference - . + .

    + + C++ ABI Reference + - .

    - Intel® Compilers for Linux* -Compatibility with the GNU Compilers - . + .

    + + Intel Compilers for Linux Compatibility with the GNU Compilers + - .

    - Sun Solaris 2.9 : Linker and Libraries Guide (document 816-1386) - . + .

    + + Sun Solaris 2.9 : Linker and Libraries Guide (document 816-1386) + - .

    - Sun Solaris 2.9 : C++ Migration Guide (document 816-2459) - . + .

    + + Sun Solaris 2.9 : C++ Migration Guide (document 816-2459) + - .

    - How to Write Shared Libraries - . Ulrich Drepper. + .

    + + How to Write Shared Libraries + - .

    - C++ ABI for the ARM Architecture - . + . Ulrich Drepper.

    + + C++ ABI for the ARM Architecture + - .

    - Dynamic Shared Objects: Survey and Issues - . - ISO C++ J16/06-0046 - . Benjamin Kosnik. + .

    + + Dynamic Shared Objects: Survey and Issues + - .

    - Versioning With Namespaces - . - ISO C++ J16/06-0083 - . Benjamin Kosnik. + . + ISO C++ J16/06-0046 + . Benjamin Kosnik.

    + + Versioning With Namespaces + - .

    - Binary Compatibility of Shared Libraries Implemented in C++ on GNU/Linux Systems - . -SYRCoSE 2009 - . Pavel Shved. Denis Silakov. + . + ISO C++ J16/06-0083 + . Benjamin Kosnik.

    + + Binary Compatibility of Shared Libraries Implemented in C++ + on GNU/Linux Systems + - .

    Prev Up Next
    Test Home API Evolution and Deprecation History
    + . + SYRCoSE 2009 + . Pavel Shved. Denis Silakov.

    Prev Up Next
    Test Home API Evolution and Deprecation History
    diff --git a/libstdc++-v3/doc/html/manual/algorithms.html b/libstdc++-v3/doc/html/manual/algorithms.html dissimilarity index 86% index 6049cd8ec0e..3e5b3a5a86e 100644 --- a/libstdc++-v3/doc/html/manual/algorithms.html +++ b/libstdc++-v3/doc/html/manual/algorithms.html @@ -1,9 +1,61 @@ - - -Part IX.  Algorithms
    Part IX.  - Algorithms - -
    Prev The GNU C++ Library Next

    Part IX.  - Algorithms - -

    Table of Contents

    20. Mutating
    swap
    Specializations
    Prev Up Next
    One Past the End Home 
    + + +Chapter 11.  Algorithms
    Chapter 11.  + Algorithms + +
    Prev Part II.  + Standard Contents + Next

    Chapter 11.  + Algorithms + +

    Table of Contents

    Mutating
    swap

    + The neatest accomplishment of the algorithms sect1 is that all the + work is done via iterators, not containers directly. This means two + important things: +

    1. + Anything that behaves like an iterator can be used in one of + these algorithms. Raw pointers make great candidates, thus + built-in arrays are fine containers, as well as your own + iterators. +

    2. + The algorithms do not (and cannot) affect the container as a + whole; only the things between the two iterator endpoints. If + you pass a range of iterators only enclosing the middle third of + a container, then anything outside that range is inviolate. +

    + Even strings can be fed through the algorithms here, although the + string class has specialized versions of many of these functions + (for example, string::find()). Most of the examples + on this page will use simple arrays of integers as a playground + for algorithms, just to keep things simple. The use of + N as a size in the examples is to keep things + easy to read but probably won't be valid code. You can use wrappers + such as those described in + the containers sect1 to keep + real code readable. +

    + The single thing that trips people up the most is the definition + of range used with iterators; the famous + "past-the-end" rule that everybody loves to hate. The + iterators sect1 of this + document has a complete explanation of this simple rule that seems + to cause so much confusion. Once you + get range into your head (it's not that hard, + honest!), then the algorithms are a cakewalk. +

    Mutating

    swap

    Specializations

    If you call std::swap(x,y); where x and y are standard + containers, then the call will automatically be replaced by a call to + x.swap(y); instead. +

    This allows member functions of each container class to take over, and + containers' swap functions should have O(1) complexity according to + the standard. (And while "should" allows implementations to + behave otherwise and remain compliant, this implementation does in + fact use constant-time swaps.) This should not be surprising, since + for two containers of the same type to swap contents, only some + internal pointers to storage need to be exchanged. +

    Prev Up Next
    Chapter 10.  + Iterators + + Home Chapter 12.  + Numerics + +
    diff --git a/libstdc++-v3/doc/html/manual/api.html b/libstdc++-v3/doc/html/manual/api.html index 0b70a4cb1bc..a8b88b7d5a9 100644 --- a/libstdc++-v3/doc/html/manual/api.html +++ b/libstdc++-v3/doc/html/manual/api.html @@ -30,8 +30,8 @@ Removal of ext/tree, moved to backward/strstream.h.

    Allocator changes. Change __malloc_alloc to malloc_allocator and __new_alloc to new_allocator.

    For GCC releases from 2.95 through the 3.1 series, defining __USE_MALLOC on the gcc command line would change the default allocation strategy to instead use malloc and - free. (This same functionality is now spelled _GLIBCXX_FORCE_NEW, see - this page + free. (This same functionality is now spelled _GLIBCXX_FORCE_NEW, see + this page for details.

    Error handling in iostreams cleaned up, made consistent.

    3.3

    3.4

    @@ -75,11 +75,11 @@ _Alloc_traits have been removed. __alloc to select an underlying allocator that satisfied memory allocation requests. The selection of this underlying allocator was not user-configurable. -

    Table B.1. Extension Allocators

    Allocator (3.4)Header (3.4)Allocator (3.[0-3])Header (3.[0-3])
    __gnu_cxx::new_allocator<T>ext/new_allocator.hstd::__new_allocmemory
    __gnu_cxx::malloc_allocator<T>ext/malloc_allocator.hstd::__malloc_alloc_template<int>memory
    __gnu_cxx::debug_allocator<T>ext/debug_allocator.hstd::debug_alloc<T>memory
    __gnu_cxx::__pool_alloc<T>ext/pool_allocator.hstd::__default_alloc_template<bool,int>memory
    __gnu_cxx::__mt_alloc<T>ext/mt_allocator.h
    __gnu_cxx::bitmap_allocator<T>ext/bitmap_allocator.h

    Releases after gcc-3.4 have continued to add to the collection +

    Table B.1. Extension Allocators

    Allocator (3.4)Header (3.4)Allocator (3.[0-3])Header (3.[0-3])
    __gnu_cxx::new_allocator<T>ext/new_allocator.hstd::__new_allocmemory
    __gnu_cxx::malloc_allocator<T>ext/malloc_allocator.hstd::__malloc_alloc_template<int>memory
    __gnu_cxx::debug_allocator<T>ext/debug_allocator.hstd::debug_alloc<T>memory
    __gnu_cxx::__pool_alloc<T>ext/pool_allocator.hstd::__default_alloc_template<bool,int>memory
    __gnu_cxx::__mt_alloc<T>ext/mt_allocator.h
    __gnu_cxx::bitmap_allocator<T>ext/bitmap_allocator.h

    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. -

    Table B.2. Extension Allocators Continued

    AllocatorIncludeVersion
    __gnu_cxx::array_allocator<T>ext/array_allocator.h4.0.0
    __gnu_cxx::throw_allocator<T>ext/throw_allocator.h4.2.0

    +

    Table B.2. Extension Allocators Continued

    AllocatorIncludeVersion
    __gnu_cxx::array_allocator<T>ext/array_allocator.h4.0.0
    __gnu_cxx::throw_allocator<T>ext/throw_allocator.h4.2.0

    Debug mode first appears.

    Precompiled header support PCH support. @@ -143,13 +143,13 @@ Debug mode for unordered_map and tuple and - functional. + functional.

    Default what implementations give more elaborate exception strings for bad_cast, bad_typeid, bad_exception, and bad_alloc.

    -PCH binary files no longer installed. Instead, the source files are installed. +PCH binary files no longer installed. Instead, the source files are installed.

    Namespace pb_ds moved to __gnu_pb_ds.

    4.4

    @@ -227,7 +227,7 @@ C++0X features.

    Profile mode first appears.

    -Support for decimal floating-point arithmetic, including decimal32, decimal64, and decimal128. +Support for decimal floating-point arithmetic, including decimal32, decimal64, and decimal128.

    Python pretty-printers are added for use with appropriately-advanced versions of gdb.

    diff --git a/libstdc++-v3/doc/html/manual/appendix_contributing.html b/libstdc++-v3/doc/html/manual/appendix_contributing.html index 422b57a813e..467f7fd0988 100644 --- a/libstdc++-v3/doc/html/manual/appendix_contributing.html +++ b/libstdc++-v3/doc/html/manual/appendix_contributing.html @@ -1,17 +1,19 @@ -Appendix A.  Contributing

    Appendix A.  +Appendix A.  Contributing
    Appendix A.  Contributing -
    Prev The GNU C++ Library Next

    Appendix A.  +

    Prev Part IV.  + Appendices + Next

    Appendix A.  Contributing - -

    Table of Contents

    Contributor Checklist
    Reading
    Assignment
    Getting Sources
    Submitting Patches
    Directory Layout and Source Conventions
    Coding Style
    Bad Identifiers
    By Example
    Documentation Style
    Doxygen
    Docbook
    Design Notes

    + +

    Table of Contents

    Contributor Checklist
    Reading
    Assignment
    Getting Sources
    Submitting Patches
    Directory Layout and Source Conventions
    Coding Style
    Bad Identifiers
    By Example
    Documentation Style
    Doxygen
    Docbook
    Combines
    Design Notes

    The GNU C++ Library follows an open development model. Active contributors are assigned maintainer-ship responsibility, and given write access to the source repository. First time contributors should follow this procedure: -

    Contributor Checklist

    Reading

    • +

      Contributor Checklist

      Reading

      • Get and read the relevant sections of the C++ language specification. Copies of the full ISO 14882 standard are available on line via the ISO mirror site for committee @@ -21,29 +23,29 @@ the standard from their respective national standards organization. In the USA, this national standards organization is ANSI and their web-site is right - here. - (And if you've already registered with them, clicking this link will take you to directly to the place where you can + here. + (And if you've already registered with them, clicking this link will take you to directly to the place where you can buy the standard on-line.) -

      • +

      • The library working group bugs, and known defects, can be obtained here: http://www.open-std.org/jtc1/sc22/wg21 -

      • +

      • The newsgroup dedicated to standardization issues is comp.std.c++: this FAQ for this group is quite useful and can be found here . -

      • +

      • Peruse the GNU Coding Standards, and chuckle when you hit the part about “Using Languages Other Than C”. -

      • +

      • Be familiar with the extensions that preceded these general GNU rules. These style issues for libstdc++ can be found here. -

      • +

      • And last but certainly not least, read the library-specific information found here. @@ -51,8 +53,8 @@ Small changes can be accepted without a copyright assignment form on file. New code and additions to the library need completed copyright assignment form on file at the FSF. Note: your employer may be required - to fill out appropriate disclaimer forms as well. -

        + to fill out appropriate disclaimer forms as well. +

        Historically, the libstdc++ assignment form added the following question:

        @@ -64,7 +66,7 @@ While not strictly necessary, humoring the maintainers and answering this question would be appreciated.

        - For more information about getting a copyright assignment, please see + For more information about getting a copyright assignment, please see Legal Matters.

        @@ -81,22 +83,22 @@ Every patch must have several pieces of information before it can be properly evaluated. Ideally (and to ensure the fastest possible response from the maintainers) it would have all of these pieces: -

        • +

          • A description of the bug and how your patch fixes this bug. For new features a description of the feature and your - implementation. -

          • + implementation. +

          • A ChangeLog entry as plain text; see the various ChangeLog files for format and content. If you are using emacs as your editor, simply position the insertion point at the beginning of your change and hit CX-4a to bring up the appropriate ChangeLog entry. See--magic! Similar - functionality also exists for vi. -

          • + functionality also exists for vi. +

          • A testsuite submission or sample program that will easily and simply show the existing error or test new - functionality. -

          • + functionality. +

          • The patch itself. If you are accessing the SVN repository use svn update; svn diff NEW; else, use diff -cp OLD NEW ... If your @@ -105,9 +107,11 @@ diff. The SVN Tricks wiki page has information on customising the output of svn diff. -

          • +

          • When you have all these pieces, bundle them up in a mail message and send it to libstdc++@gcc.gnu.org. All patches and related discussion should be sent to the - libstdc++ mailing list. -

      Prev Up Next
      Use Home Directory Layout and Source Conventions
      + libstdc++ mailing list. +

    Prev Up Next
    Part IV.  + Appendices + Home Directory Layout and Source Conventions
    diff --git a/libstdc++-v3/doc/html/manual/appendix_free.html b/libstdc++-v3/doc/html/manual/appendix_free.html index dd77c972f07..bc6c37655ea 100644 --- a/libstdc++-v3/doc/html/manual/appendix_free.html +++ b/libstdc++-v3/doc/html/manual/appendix_free.html @@ -1,11 +1,13 @@ -Appendix C.  Free Software Needs Free Documentation
    Appendix C.  +Appendix C.  Free Software Needs Free Documentation
    Appendix C.  Free Software Needs Free Documentation -
    Prev The GNU C++ Library Next

    Appendix C.  +

    Prev Part IV.  + Appendices + Next

    Appendix C.  Free Software Needs Free Documentation - +

    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 @@ -35,7 +37,7 @@ restrict it so that we cannot use it.

    Given that writing good English is a rare skill among programmers, we can ill afford to lose manuals this way. -

    +

    Free documentation, like free software, is a matter of freedom, not price. The problem with these manuals was not that O'Reilly Associates charged a price for printed copies--that in itself is fine. @@ -119,6 +121,6 @@ prefer copylefted manuals to non-copylefted ones. that lists free books available from other publishers].

    Copyright © 2004, 2005, 2006, 2007 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

    Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this -notice is preserved.

    Report any problems or suggestions to .

    Prev Up Next
    Backwards Compatibility Home Appendix D.  +notice is preserved.

    Report any problems or suggestions to .

    Prev Up Next
    Backwards Compatibility Home Appendix D.  GNU General Public License version 3
    diff --git a/libstdc++-v3/doc/html/manual/appendix_gfdl.html b/libstdc++-v3/doc/html/manual/appendix_gfdl.html index 6b6e69ea86d..edb2f0c3f4d 100644 --- a/libstdc++-v3/doc/html/manual/appendix_gfdl.html +++ b/libstdc++-v3/doc/html/manual/appendix_gfdl.html @@ -1,6 +1,8 @@ -Appendix E. GNU Free Documentation License
    Appendix E. GNU Free Documentation License
    Prev The GNU C++ Library Next

    Appendix E. GNU Free Documentation License

    +Appendix E. GNU Free Documentation License

    Appendix E. GNU Free Documentation License
    Prev Part IV.  + Appendices + Next

    Appendix E. GNU Free Documentation License

    Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. Everyone is permitted to copy and @@ -390,6 +392,6 @@ recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software. -

    Prev Up Next
    Appendix D.  +

    Prev Up Next
    Appendix D.  GNU General Public License version 3 -  Home Index
    +      		Home 
    diff --git a/libstdc++-v3/doc/html/manual/appendix_gpl.html b/libstdc++-v3/doc/html/manual/appendix_gpl.html index 5dd0a7da6d1..42a68eca06d 100644 --- a/libstdc++-v3/doc/html/manual/appendix_gpl.html +++ b/libstdc++-v3/doc/html/manual/appendix_gpl.html @@ -1,8 +1,10 @@ -Appendix D.  GNU General Public License version 3
    Appendix D.  +Appendix D.  GNU General Public License version 3
    Appendix D.  GNU General Public License version 3 -
    Prev The GNU C++ Library Next

    Appendix D.  +

    Prev Part IV.  + Appendices + Next

    Appendix D.  GNU General Public License version 3

    Version 3, 29 June 2007 @@ -76,7 +78,7 @@

    The precise terms and conditions for copying, distribution and modification follow. -

    +

    TERMS AND CONDITIONS

    0. Definitions. @@ -617,7 +619,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. -

    +

    END OF TERMS AND CONDITIONS

    How to Apply These Terms to Your New Programs @@ -675,7 +677,7 @@ under certain conditions; type ‘show c’ for det proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read http://www.gnu.org/philosophy/why-not-lgpl.html. -

    Prev Up Next
    Appendix C.  +

    Prev Up Next
    Appendix C.  Free Software Needs Free Documentation  Home Appendix E. GNU Free Documentation License
    diff --git a/libstdc++-v3/doc/html/manual/appendix_porting.html b/libstdc++-v3/doc/html/manual/appendix_porting.html index ef6924f2892..47d342a193f 100644 --- a/libstdc++-v3/doc/html/manual/appendix_porting.html +++ b/libstdc++-v3/doc/html/manual/appendix_porting.html @@ -1,12 +1,14 @@ -Appendix B.  Porting and Maintenance
    Appendix B.  +Appendix B.  Porting and Maintenance
    Appendix B.  Porting and Maintenance -
    Prev The GNU C++ Library Next

    Appendix B.  +

    Prev Part IV.  + Appendices + Next

    Appendix B.  Porting and Maintenance - -

    Table of Contents

    Configure and Build Hacking
    Prerequisites
    Overview: What Comes from Where
    Storing Information in non-AC files (like configure.host)
    Coding and Commenting Conventions
    The acinclude.m4 layout
    GLIBCXX_ENABLE, the --enable maker
    Porting to New Hardware or Operating Systems
    Operating System
    CPU
    Character Types
    Thread Safety
    Numeric Limits
    Libtool
    Test
    Organization
    Running the Testsuite
    Writing a new test case
    Test Harness and Utilities
    Special Topics
    ABI Policy and Guidelines
    The C++ Interface
    Versioning
    Allowed Changes
    Prohibited Changes
    Implementation
    Testing
    Outstanding Issues
    API Evolution and Deprecation History
    3.0
    3.1
    3.2
    3.3
    3.4
    4.0
    4.1
    4.2
    4.3
    4.4
    4.5
    Backwards Compatibility
    First
    Second
    Third

    Configure and Build Hacking

    Prerequisites

    + +

    Table of Contents

    Configure and Build Hacking
    Prerequisites
    Overview: What Comes from Where
    Storing Information in non-AC files (like configure.host)
    Coding and Commenting Conventions
    The acinclude.m4 layout
    GLIBCXX_ENABLE, the --enable maker
    Porting to New Hardware or Operating Systems
    Operating System
    CPU
    Character Types
    Thread Safety
    Numeric Limits
    Libtool
    Test
    Organization
    Running the Testsuite
    Writing a new test case
    Test Harness and Utilities
    Special Topics
    ABI Policy and Guidelines
    The C++ Interface
    Versioning
    Allowed Changes
    Prohibited Changes
    Implementation
    Testing
    Outstanding Issues
    API Evolution and Deprecation History
    3.0
    3.1
    3.2
    3.3
    3.4
    4.0
    4.1
    4.2
    4.3
    4.4
    4.5
    Backwards Compatibility
    First
    Second
    Third

    Configure and Build Hacking

    Prerequisites

    As noted previously, certain other tools are necessary for hacking on files that control configure (configure.ac, @@ -227,4 +229,4 @@ argument checking at all is done in this signature. See GLIBCXX_ENABLE_CXX_FLAGS for an example of handling, and an error message. -

    Prev Up Next
    Design Notes Home Porting to New Hardware or Operating Systems
    +

    Prev Up Next
    Design Notes Home Porting to New Hardware or Operating Systems
    diff --git a/libstdc++-v3/doc/html/manual/associative.html b/libstdc++-v3/doc/html/manual/associative.html index bf0731243c9..2173413e41c 100644 --- a/libstdc++-v3/doc/html/manual/associative.html +++ b/libstdc++-v3/doc/html/manual/associative.html @@ -1,9 +1,9 @@ -Chapter 17. Associative
    Chapter 17. Associative
    Prev Part VII.  +Associative
    Associative
    Prev Chapter 9.  Containers - Next

    Chapter 17. Associative

    Table of Contents

    Insertion Hints
    bitset
    Size Variable
    Type String

    Insertion Hints

    +

    		 Next

    Associative

    Insertion Hints

    Section [23.1.2], Table 69, of the C++ standard lists this function for all of the associative containers (map, set, etc): 

    @@ -48,7 +48,7 @@
 	  end(), then the item being inserted should have
 	  a key greater than all the other keys in the container.  The
 	  item will be inserted at the end of the container, becoming
-	  the new entry before end().  
+	  the new entry before end().
       
  • 
 	  neither begin() nor end(), then:
 	  Let h be the entry in the container pointed to
@@ -84,4 +84,109 @@
      the new item would in fact belong there.  If the hint does not
      point to the correct place, then no further local searching is
      done; the search begins from scratch in logarithmic time.
-
    • Prev Up Next
    vector Home bitset
    +

    bitset

    Size Variable

    + No, you cannot write code of the form + 

    +      #include <bitset>
+
+      void foo (size_t n)
+      {
+	  std::bitset<n>   bits;
+	  ....
+      }
+

    + because n must be known at compile time. Your + compiler is correct; it is not a bug. That's the way templates + work. (Yes, it is a feature.) +

    + There are a couple of ways to handle this kind of thing. Please + consider all of them before passing judgement. They include, in + no chaptericular order: +

    • A very large N in bitset<N>.

    • A container<bool>.

    • Extremely weird solutions.

    + A very large N in + bitset<N>.   It has been + pointed out a few times in newsgroups that N bits only takes up + (N/8) bytes on most systems, and division by a factor of eight is + pretty impressive when speaking of memory. Half a megabyte given + over to a bitset (recall that there is zero space overhead for + housekeeping info; it is known at compile time exactly how large + the set is) will hold over four million bits. If you're using + those bits as status flags (e.g., + “changed”/“unchanged” flags), that's a + lot of state. +

    + You can then keep track of the “maximum bit used” + during some testing runs on representative data, make note of how + many of those bits really need to be there, and then reduce N to + a smaller number. Leave some extra space, of course. (If you + plan to write code like the incorrect example above, where the + bitset is a local variable, then you may have to talk your + compiler into allowing that much stack space; there may be zero + space overhead, but it's all allocated inside the object.) +

    + A container<bool>.   The + Committee made provision for the space savings possible with that + (N/8) usage previously mentioned, so that you don't have to do + wasteful things like Container<char> or + Container<short int>. Specifically, + vector<bool> is required to be specialized for + that space savings. +

    + The problem is that vector<bool> doesn't + behave like a normal vector anymore. There have been + journal articles which discuss the problems (the ones by Herb + Sutter in the May and July/August 1999 issues of C++ Report cover + it well). Future revisions of the ISO C++ Standard will change + the requirement for vector<bool> + specialization. In the meantime, deque<bool> + is recommended (although its behavior is sane, you probably will + not get the space savings, but the allocation scheme is different + than that of vector). +

    + Extremely weird solutions.   If + you have access to the compiler and linker at runtime, you can do + something insane, like figuring out just how many bits you need, + then writing a temporary source code file. That file contains an + instantiation of bitset for the required number of + bits, inside some wrapper functions with unchanging signatures. + Have your program then call the compiler on that file using + Position Independent Code, then open the newly-created object + file and load those wrapper functions. You'll have an + instantiation of bitset<N> for the exact + N that you need at the time. Don't forget to delete + the temporary files. (Yes, this can be, and + has been, done.) +

    + This would be the approach of either a visionary genius or a + raving lunatic, depending on your programming and management + style. Probably the latter. +

    + Which of the above techniques you use, if any, are up to you and + your intended application. Some time/space profiling is + indicated if it really matters (don't just guess). And, if you + manage to do anything along the lines of the third category, the + author would love to hear from you... +

    + Also note that the implementation of bitset used in libstdc++ has + some extensions. +

    Type String

    +

    + Bitmasks do not take char* nor const char* arguments in their + constructors. This is something of an accident, but you can read + about the problem: follow the library's “Links” from + the homepage, and from the C++ information “defect + reflector” link, select the library issues list. Issue + number 116 describes the problem. +

    + For now you can simply make a temporary string object using the + constructor expression: + 

    +      std::bitset<5> b ( std::string(“10110”) );
+

    + instead of + 

    +      std::bitset<5> b ( “10110” );    // invalid
+
    Prev Up Next
    Chapter 9.  + Containers + + Home Interacting with C
    diff --git a/libstdc++-v3/doc/html/manual/atomics.html b/libstdc++-v3/doc/html/manual/atomics.html new file mode 100644 index 00000000000..1db9a81fbe1 --- /dev/null +++ b/libstdc++-v3/doc/html/manual/atomics.html @@ -0,0 +1,31 @@ + + +Chapter 14.  Atomics
    Chapter 14.  + Atomics + +
    Prev Part II.  + Standard Contents + Next

    Chapter 14.  + Atomics + +

    Table of Contents

    API Reference

    + Facilities for atomic operations. +

    API Reference

    + All items are declared in the standard header + file atomic. +

    + Set of typedefs that map int to + atomic_int, and so on for all builtin + integral types. Global enumeration memory_order to + control memory ordering. Also includes + atomic, a class template with member + functions such as load and + store that is instantiable such that + atomic_int is the base class of + atomic<int>. +

    + Full API details. +

    Prev Up Next
    Interacting with C Home Chapter 15.  + Concurrency + +
    diff --git a/libstdc++-v3/doc/html/manual/auto_ptr.html b/libstdc++-v3/doc/html/manual/auto_ptr.html deleted file mode 100644 index 777264504bf..00000000000 --- a/libstdc++-v3/doc/html/manual/auto_ptr.html +++ /dev/null @@ -1,90 +0,0 @@ - - -auto_ptr
    auto_ptr
    Prev Chapter 11. Memory Next

    auto_ptr

    Limitations

    Explaining all of the fun and delicious things that can - happen with misuse of the auto_ptr class - template (called AP here) would take some - time. Suffice it to say that the use of AP - safely in the presence of copying has some subtleties. -

    - The AP class is a really - nifty idea for a smart pointer, but it is one of the dumbest of - all the smart pointers -- and that's fine. -

    - AP is not meant to be a supersmart solution to all resource - leaks everywhere. Neither is it meant to be an effective form - of garbage collection (although it can help, a little bit). - And it can notbe used for arrays! -

    - AP is meant to prevent nasty leaks in the - presence of exceptions. That's all. This - code is AP-friendly: - 

    -    // Not a recommend naming scheme, but good for web-based FAQs.
-    typedef std::auto_ptr<MyClass>  APMC;
-
-    extern function_taking_MyClass_pointer (MyClass*);
-    extern some_throwable_function ();
-
-    void func (int data)
-    {
-        APMC  ap (new MyClass(data));
-
-        some_throwable_function();   // this will throw an exception
-
-        function_taking_MyClass_pointer (ap.get());
-    }
-

    When an exception gets thrown, the instance of MyClass that's - been created on the heap will be delete'd as the stack is - unwound past func(). -

    Changing that code as follows is not AP-friendly: - 

    -        APMC  ap (new MyClass[22]);
-

    You will get the same problems as you would without the use - of AP: - 

    -        char*  array = new char[10];       // array new...
-        ...
-        delete array;                      // ...but single-object delete
-

    - AP cannot tell whether the pointer you've passed at creation points - to one or many things. If it points to many things, you are about - to die. AP is trivial to write, however, so you could write your - own auto_array_ptr for that situation (in fact, this has - been done many times; check the mailing lists, Usenet, Boost, etc). -

    Use in Containers

    -

    All of the containers - described in the standard library require their contained types - to have, among other things, a copy constructor like this: - 

    -    struct My_Type
-    {
-        My_Type (My_Type const&);
-    };
-

    - Note the const keyword; the object being copied shouldn't change. - The template class auto_ptr (called AP here) does not - meet this requirement. Creating a new AP by copying an existing - one transfers ownership of the pointed-to object, which means that - the AP being copied must change, which in turn means that the - copy ctors of AP do not take const objects. -

    - The resulting rule is simple: Never ever use a - container of auto_ptr objects. The standard says that - “undefined” behavior is the result, but it is - guaranteed to be messy. -

    - To prevent you from doing this to yourself, the - concept checks built - in to this implementation will issue an error if you try to - compile code like this: - 

    -    #include <vector>
-    #include <memory>
-    
-    void f()
-    {
-        std::vector< std::auto_ptr<int> >   vec_ap_int;
-    }
-

    -Should you try this with the checks enabled, you will see an error. -

    Prev Up Next
    Chapter 11. Memory Home shared_ptr
    diff --git a/libstdc++-v3/doc/html/manual/backwards.html b/libstdc++-v3/doc/html/manual/backwards.html index 2844247f184..8656c934d1f 100644 --- a/libstdc++-v3/doc/html/manual/backwards.html +++ b/libstdc++-v3/doc/html/manual/backwards.html @@ -17,8 +17,8 @@ ISO Standard (e.g., statistical analysis). While there are a lot of really useful things that are used by a lot of people, the Standards Committee couldn't include everything, and so a lot of those “obvious” classes didn't get included. -

    Known Issues include many of the limitations of its immediate ancestor.

    Portability notes and known implementation limitations are as follows.

    No ios_base

    At least some older implementations don't have std::ios_base, so you should use std::ios::badbit, std::ios::failbit and std::ios::eofbit and std::ios::goodbit. -

    No cout in ostream.h, no cin in istream.h

    +

    Known Issues include many of the limitations of its immediate ancestor.

    Portability notes and known implementation limitations are as follows.

    No ios_base

    At least some older implementations don't have std::ios_base, so you should use std::ios::badbit, std::ios::failbit and std::ios::eofbit and std::ios::goodbit. +

    No cout in ostream.h, no cin in istream.h

    In earlier versions of the standard, fstream.h, ostream.h @@ -32,26 +32,26 @@ archived. For the desperate, the GCC extensions page describes where to find the last libg++ source. The code is considered replaced and rewritten. -

    Second

    +

    Second

    The second generation GNU C++ library was called libstdc++, or libstdc++-v2. It spans the time between libg++ and pre-ISO C++ standardization and is usually associated with the following GCC releases: egcs 1.x, gcc 2.95, and gcc 2.96. -

    +

    The STL portions of this library are based on SGI/HP STL release 3.11.

    This project is no longer maintained or supported, and the sources archived. The code is considered replaced and rewritten.

    Portability notes and known implementation limitations are as follows. -

    Namespace std:: not supported

    +

    Namespace std:: not supported

    Some care is required to support C++ compiler and or library implementation that do not have the standard library in namespace std.

    The following sections list some possible solutions to support compilers that cannot ignore std::-qualified names. -

    +

    First, see if the compiler has a flag for this. Namespace back-portability-issues are generally not a problem for g++ compilers that do not have libstdc++ in std::, as the @@ -62,7 +62,7 @@ considered replaced and rewritten. probably applies to some other compilers as well.

    Second, experiment with a variety of pre-processor tricks. -

    +

    By defining std as a macro, fully-qualified namespace calls become global. Volia. 

    @@ -99,8 +99,8 @@ AC_DEFUN([AC_CXX_NAMESPACE_STD], [
   ac_cv_cxx_have_std_namespace,
   [AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
-  AC_TRY_COMPILE([#include <iostream> 
-                  std::istream& is = std::cin;],,
+  AC_TRY_COMPILE([#include <iostream>
+		  std::istream& is = std::cin;],,
   ac_cv_cxx_have_std_namespace=yes, ac_cv_cxx_have_std_namespace=no)
   AC_LANG_RESTORE
   ])
@@ -108,7 +108,7 @@ AC_DEFUN([AC_CXX_NAMESPACE_STD], [
     AC_DEFINE(HAVE_NAMESPACE_STD,,[Define if g++ supports namespace std. ])
   fi
 ])
-

    Illegal iterator usage

    +

    Illegal iterator usage

    The following illustrate implementation-allowed illegal iterator use, and then correct use.

    • @@ -120,28 +120,28 @@ AC_DEFUN([AC_CXX_NAMESPACE_STD], [ 0) => use iterator = iterator_type();

    • if (iterator) won't work any more => use - if (iterator != iterator_type()) -

    isspace from cctype is a macro -

    + if (iterator != iterator_type()) +

    isspace from cctype is a macro +

    Glibc 2.0.x and 2.1.x define ctype.h functionality as macros (isspace, isalpha etc.).

    This implementations of libstdc++, however, keep these functions as macros, and so it is not back-portable to use fully qualified names. For example: - 

     
-#include <cctype> 
-int main() { std::isspace('X'); } 
+  
    +#include <cctype>
+int main() { std::isspace('X'); }
 
    
   Results in something like this:
-
     
-std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ; 
-
     
+
    +std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ;
+
    
   A solution is to modify a header-file so that the compiler tells
   ctype.h to define functions
   instead of macros:
 
    -// This keeps isalnum, et al from being propagated as macros. 
+// This keeps isalnum, et al from being propagated as macros.
 #if __linux__
 # define __NO_CTYPE 1
 #endif
@@ -154,7 +154,7 @@ std:: (__ctype_b[(int) ( ( 'X' ) )] & (unsigned short int) _ISspace ) ;
   (ctype.h) and the
   definitions in namespace std::
   (<cctype>).
-

    No vector::at, deque::at, string::at

    +

    No vector::at, deque::at, string::at

    One solution is to add an autoconf-test for this: 

     AC_MSG_CHECKING(for container::at)
@@ -163,7 +163,7 @@ AC_TRY_COMPILE(
 #include <vector>
 #include <deque>
 #include <string>
-	
+
 using namespace std;
 ],
 [
@@ -180,7 +180,7 @@ AC_DEFINE(HAVE_CONTAINER_AT)],

    If you are using other (non-GNU) compilers it might be a good idea to check for string::at separately. -

    No std::char_traits<char>::eof

    +

    No std::char_traits<char>::eof

    Use some kind of autoconf test, plus this: 

     #ifdef HAVE_CHAR_TRAITS
@@ -188,45 +188,45 @@ AC_DEFINE(HAVE_CONTAINER_AT)],
 #else
 #define CPP_EOF EOF
 #endif
-

    No string::clear

    +

    No string::clear

    There are two functions for deleting the contents of a string: clear and erase (the latter returns the string). 

    -void 
+void
 clear() { _M_mutate(0, this->size(), 0); }
 
    -basic_string& 
+basic_string&
 erase(size_type __pos = 0, size_type __n = npos)
-{ 
+{
   return this->replace(_M_check(__pos), _M_fold(__pos, __n),
-                          _M_data(), _M_data()); 
+			  _M_data(), _M_data());
 }

    Unfortunately, clear is not implemented in this version, so you should use erase (which is probably faster than operator=(charT*)). -

    +

    Removal of ostream::form and istream::scan extensions -

    +

    These are no longer supported. Please use stringstreams instead. -

    No basic_stringbuf, basic_stringstream

    +

    No basic_stringbuf, basic_stringstream

    Although the ISO standard i/ostringstream-classes are provided, (sstream), for compatibility with older implementations the pre-ISO i/ostrstream (strstream) interface is also provided, with these caveats: -

    • +

      • strstream is considered to be deprecated -

      • +

      • strstream is limited to char -

      • +

      • with ostringstream you don't have to take care of - terminating the string or freeing its memory -

      • + terminating the string or freeing its memory +

      • istringstream can be re-filled (clear(); - str(input);) + str(input);)

      You can then use output-stringstreams like this: 

      @@ -268,7 +268,7 @@ std::istrstream iss(input.c_str());
 #endif
 
 int i;
-iss >> i; 
+iss >> i;

      One (the only?) restriction is that an istrstream cannot be re-filled: 

       std::istringstream iss(numerator);
@@ -295,18 +295,18 @@ if (iss.fail())
 throw runtime_error(..)
 any = temp;
 }
-

      - Another example of using stringstreams is in this howto. +

      + Another example of using stringstreams is in this howto.

      There is additional information in the libstdc++-v2 info files, in particular “info iostream”. -

    Little or no wide character support

    +

    Little or no wide character support

    Classes wstring and char_traits<wchar_t> are not supported. -

    No templatized iostreams

    +

    No templatized iostreams

    Classes wfilebuf and wstringstream are not supported. -

    Thread safety issues

    +

    Thread safety issues

    Earlier GCC releases had a somewhat different approach to threading configuration and proper compilation. Before GCC 3.0, configuration of the threading model was dictated by compiler @@ -348,10 +348,10 @@ particular “info iostream”

  • - This message inspired a recent updating of issues with - threading and the SGI STL library. It also contains some - example POSIX-multithreaded STL code. -

    • + This message inspired a recent updating of issues with + threading and the SGI STL library. It also contains some + example POSIX-multithreaded STL code. +

    (A large selection of links to older messages has been removed; many of the messages from 1999 were lost in a disk crash, and the few people with access to the backup tapes have been too swamped @@ -360,11 +360,11 @@ particular “info iostream”

    Third

    The third generation GNU C++ library is called libstdc++, or libstdc++-v3.

    The subset commonly known as the Standard Template Library - (chapters 23 through 25, mostly) is adapted from the final release - of the SGI STL (version 3.3), with extensive changes. + (chapters 23 through 25, mostly) is adapted from the final release + of the SGI STL (version 3.3), with extensive changes.

    A more formal description of the V3 goals can be found in the - official design document. -

    Portability notes and known implementation limitations are as follows.

    Pre-ISO headers moved to backwards or removed

    The pre-ISO C++ headers + official design document. +

    Portability notes and known implementation limitations are as follows.

    Pre-ISO headers moved to backwards or removed

    The pre-ISO C++ headers (iostream.h, defalloc.h etc.) are available, unlike previous libstdc++ versions, but inclusion generates a warning that you are using deprecated headers. @@ -385,7 +385,7 @@ AC_DEFUN([AC_HEADER_PRE_STDCXX], [ [AC_LANG_SAVE AC_LANG_CPLUSPLUS ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS -Wno-deprecated" + CXXFLAGS="$CXXFLAGS -Wno-deprecated" # Omit defalloc.h, as compilation with newer compilers is problematic. AC_TRY_COMPILE([ @@ -436,11 +436,11 @@ like vector.h can be replaced with using namespace std; can be put at the global scope. This should be enough to get this code compiling, assuming the other usage is correct. -

    Extension headers hash_map, hash_set moved to ext or backwards

    At this time most of the features of the SGI STL extension have been - replaced by standardized libraries. - In particular, the unordered_map and unordered_set containers of TR1 - are suitable replacement for the non-standard hash_map and hash_set - containers in the SGI STL. +

    Extension headers hash_map, hash_set moved to ext or backwards

    At this time most of the features of the SGI STL extension have been + replaced by standardized libraries. + In particular, the unordered_map and unordered_set containers of TR1 + are suitable replacement for the non-standard hash_map and hash_set + containers in the SGI STL.

    Header files hash_map and hash_set moved to ext/hash_map and ext/hash_set, respectively. At the same time, all types in these files are enclosed @@ -448,29 +448,29 @@ in namespace __gnu_cxx. Later versions move deprecate these files, and suggest using TR1's unordered_map and unordered_set instead.

    The extensions are no longer in the global or std - namespaces, instead they are declared in the __gnu_cxx - namespace. For maximum portability, consider defining a namespace - alias to use to talk about extensions, e.g.: + namespaces, instead they are declared in the __gnu_cxx + namespace. For maximum portability, consider defining a namespace + alias to use to talk about extensions, e.g.: 

           #ifdef __GNUC__
       #if __GNUC__ < 3
-        #include <hash_map.h>
-        namespace extension { using ::hash_map; }; // inherit globals
+	#include <hash_map.h>
+	namespace extension { using ::hash_map; }; // inherit globals
       #else
-        #include <backward/hash_map>
-        #if __GNUC__ == 3 && __GNUC_MINOR__ == 0
-          namespace extension = std;               // GCC 3.0
-        #else
-          namespace extension = ::__gnu_cxx;       // GCC 3.1 and later
-        #endif
+	#include <backward/hash_map>
+	#if __GNUC__ == 3 && __GNUC_MINOR__ == 0
+	  namespace extension = std;               // GCC 3.0
+	#else
+	  namespace extension = ::__gnu_cxx;       // GCC 3.1 and later
+	#endif
       #endif
       #else      // ...  there are other compilers, right?
-        namespace extension = std;
+	namespace extension = std;
       #endif
 
-      extension::hash_map<int,int> my_map; 
+      extension::hash_map<int,int> my_map;

    This is a bit cleaner than defining typedefs for all the - instantiations you might need. + instantiations you might need.

    The following autoconf tests check for working HP/SGI hash containers. 

     # AC_HEADER_EXT_HASH_MAP
@@ -480,7 +480,7 @@ AC_DEFUN([AC_HEADER_EXT_HASH_MAP], [
   [AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -Werror"	
+  CXXFLAGS="$CXXFLAGS -Werror"
   AC_TRY_COMPILE([#include <ext/hash_map>], [using __gnu_cxx::hash_map;],
   ac_cv_cxx_ext_hash_map=yes, ac_cv_cxx_ext_hash_map=no)
   CXXFLAGS="$ac_save_CXXFLAGS"
@@ -498,7 +498,7 @@ AC_DEFUN([AC_HEADER_EXT_HASH_SET], [
   [AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -Werror"	
+  CXXFLAGS="$CXXFLAGS -Werror"
   AC_TRY_COMPILE([#include <ext/hash_set>], [using __gnu_cxx::hash_set;],
   ac_cv_cxx_ext_hash_set=yes, ac_cv_cxx_ext_hash_set=no)
   CXXFLAGS="$ac_save_CXXFLAGS"
@@ -508,7 +508,7 @@ AC_DEFUN([AC_HEADER_EXT_HASH_SET], [
     AC_DEFINE(HAVE_EXT_HASH_SET,,[Define if ext/hash_set is present. ])
   fi
 ])
-

    No ios::nocreate/ios::noreplace. +

    No ios::nocreate/ios::noreplace.

    The existence of ios::nocreate being used for input-streams has been confirmed, most probably because the author thought it would be more correct to specify nocreate explicitly. So @@ -519,7 +519,7 @@ open the file for reading, check if it has been opened, and then decide whether you want to create/replace or not. To my knowledge, even older implementations support app, ate and trunc (except for app ?). -

    +

    No stream::attach(int fd)

    Phil Edwards writes: It was considered and rejected for the ISO @@ -531,7 +531,7 @@ No stream::attach(int fd) std::streambuf (or std::basic_streambuf<..>) which opens a file given a descriptor, and then pass an instance of this to the - stream-constructor. + stream-constructor.

    An extension is available that implements this. ext/stdio_filebuf.h contains a derived class called @@ -540,9 +540,9 @@ No stream::attach(int fd) descriptor, and provides the fd() function.

    For another example of this, refer to - fdstream example + fdstream example by Nicolai Josuttis. -

    +

    Support for C++98 dialect.

    Check for complete library coverage of the C++1998/2003 standard. 

    @@ -610,7 +610,7 @@ AC_DEFUN([AC_HEADER_STDCXX_98], [
     AC_DEFINE(STDCXX_98_HEADERS,,[Define if ISO C++ 1998 header files are present. ])
   fi
 ])
-

    +

    Support for C++TR1 dialect.

    Check for library coverage of the TR1 standard. 

    @@ -687,7 +687,7 @@ AC_DEFUN([AC_HEADER_TR1_UNORDERED_SET], [
     AC_DEFINE(HAVE_TR1_UNORDERED_SET,,[Define if tr1/unordered_set is present. ])
   fi
 ])
-

    +

    Support for C++0x dialect.

    Check for baseline language coverage in the compiler for the C++0xstandard. 

    @@ -699,7 +699,7 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [
   AC_LANG_CPLUSPLUS
   AC_TRY_COMPILE([
   template <typename T>
-    struct check 
+    struct check
     {
       static_assert(sizeof(int) <= sizeof(T), "not big enough");
     };
@@ -721,10 +721,10 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [
   [AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -std=c++0x"	
+  CXXFLAGS="$CXXFLAGS -std=c++0x"
   AC_TRY_COMPILE([
   template <typename T>
-    struct check 
+    struct check
     {
       static_assert(sizeof(int) <= sizeof(T), "not big enough");
     };
@@ -747,10 +747,10 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [
   [AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -std=gnu++0x"	
+  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
   AC_TRY_COMPILE([
   template <typename T>
-    struct check 
+    struct check
     {
       static_assert(sizeof(int) <= sizeof(T), "not big enough");
     };
@@ -768,8 +768,8 @@ AC_DEFUN([AC_COMPILE_STDCXX_0X], [
   AC_LANG_RESTORE
   ])
 
-  if test "$ac_cv_cxx_compile_cxx0x_native" = yes || 
-     test "$ac_cv_cxx_compile_cxx0x_cxx" = yes || 
+  if test "$ac_cv_cxx_compile_cxx0x_native" = yes ||
+     test "$ac_cv_cxx_compile_cxx0x_cxx" = yes ||
      test "$ac_cv_cxx_compile_cxx0x_gxx" = yes; then
     AC_DEFINE(HAVE_STDCXX_0X,,[Define if g++ supports C++0x features. ])
   fi
@@ -784,7 +784,7 @@ AC_DEFUN([AC_HEADER_STDCXX_0X], [
   AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -std=gnu++0x"	
+  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
 
   AC_TRY_COMPILE([
     #include <cassert>
@@ -870,7 +870,7 @@ AC_DEFUN([AC_HEADER_UNORDERED_MAP], [
   AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -std=gnu++0x"	
+  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
   AC_TRY_COMPILE([#include <unordered_map>], [using std::unordered_map;],
   ac_cv_cxx_unordered_map=yes, ac_cv_cxx_unordered_map=no)
   CXXFLAGS="$ac_save_CXXFLAGS"
@@ -889,7 +889,7 @@ AC_DEFUN([AC_HEADER_UNORDERED_SET], [
   AC_LANG_SAVE
   AC_LANG_CPLUSPLUS
   ac_save_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$CXXFLAGS -std=gnu++0x"	
+  CXXFLAGS="$CXXFLAGS -std=gnu++0x"
   AC_TRY_COMPILE([#include <unordered_set>], [using std::unordered_set;],
   ac_cv_cxx_unordered_set=yes, ac_cv_cxx_unordered_set=no)
   CXXFLAGS="$ac_save_CXXFLAGS"
@@ -899,32 +899,29 @@ AC_DEFUN([AC_HEADER_UNORDERED_SET], [
     AC_DEFINE(HAVE_UNORDERED_SET,,[Define if unordered_set is present. ])
   fi
 ])
-

    +

    Container::iterator_type is not necessarily Container::value_type*

    This is a change in behavior from the previous version. Now, most iterator_type typedefs in container classes are POD objects, not value_type pointers. -

    Bibliography

    [ - kegel41 - ] - Migrating to GCC 4.1 - . Dan Kegel. +

    Bibliography

    - - .

    [ - kegel41 - ] - Building the Whole Debian Archive with GCC 4.1: A Summary - . Martin Michlmayr. + + Migrating to GCC 4.1 + + + . Dan Kegel.

    + + Building the Whole Debian Archive with GCC 4.1: A Summary + - .

    [ - lbl32 - ] - Migration guide for GCC-3.2 - . + . Martin Michlmayr.

    + + Migration guide for GCC-3.2 + .

    Prev Up Next
    API Evolution and Deprecation History Home Appendix C.  Free Software Needs Free Documentation diff --git a/libstdc++-v3/doc/html/manual/bitmap_allocator.html b/libstdc++-v3/doc/html/manual/bitmap_allocator.html index 32a44a2bb2c..2d750160b29 100644 --- a/libstdc++-v3/doc/html/manual/bitmap_allocator.html +++ b/libstdc++-v3/doc/html/manual/bitmap_allocator.html @@ -1,6 +1,6 @@ -bitmap_allocator
    bitmap_allocator
    Prev Chapter 33. Allocators Next

    bitmap_allocator

    +bitmap_allocator

    bitmap_allocator
    Prev Chapter 20. Allocators Next

    bitmap_allocator

    Design

    As this name suggests, this allocator uses a bit-map to keep track of the used and unused memory locations for it's book-keeping @@ -103,7 +103,7 @@ else return false.

    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). -

    Table 33.1. Bitmap Allocator Memory Map

    268042949672954294967295Data -> Space for 64 ints

    +

    Table 20.1. Bitmap Allocator Memory Map

    268042949672954294967295Data -> Space for 64 ints

    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 @@ -192,20 +192,20 @@ For map/multimap: k = 12, and c = 4 (int and double), we get: 37.524% _S_refill_pool which does the following:

    • Gets more memory from the Global Free List of the Required - size. + size.

    • - Adjusts the size for the next call to itself. + Adjusts the size for the next call to itself.

    • Writes the appropriate headers in the bit-maps.

    • Sets the use count for that super-block just allocated to 0 - (zero). + (zero).

    • All of the above accounts to maintaining the basic invariant for the allocator. If the invariant is maintained, we are sure that all is well. Now, the same process is applied on the newly acquired free blocks, which are dispatched - accordingly. + accordingly.

    Thus, you can clearly see that the allocate function is nothing but a combination of the next-fit and first-fit algorithm optimized ONLY for @@ -337,4 +337,4 @@ equivalent.

  • And also this would preserve the cac sizeof(size_t) x 8 which is the number of bits in an integer, which can fit exactly in a CPU register. Hence, the term given is exponential growth of the internal pool. -

    • Prev Up Next
    Chapter 33. Allocators Home Chapter 34. Containers
    +

    Prev Up Next
    Chapter 20. Allocators Home Chapter 21. Containers
    diff --git a/libstdc++-v3/doc/html/manual/bitset.html b/libstdc++-v3/doc/html/manual/bitset.html deleted file mode 100644 index 0d9fbeb2088..00000000000 --- a/libstdc++-v3/doc/html/manual/bitset.html +++ /dev/null @@ -1,105 +0,0 @@ - - -bitset
    bitset
    Prev Chapter 17. Associative Next

    bitset

    Size Variable

    - No, you cannot write code of the form - 

    -      #include <bitset>
-
-      void foo (size_t n)
-      {
-          std::bitset<n>   bits;
-          ....
-      } 
-

    - because n must be known at compile time. Your - compiler is correct; it is not a bug. That's the way templates - work. (Yes, it is a feature.) -

    - There are a couple of ways to handle this kind of thing. Please - consider all of them before passing judgement. They include, in - no particular order: -

    • A very large N in bitset<N>.

    • A container<bool>.

    • Extremely weird solutions.

    - A very large N in - bitset<N>.   It has been - pointed out a few times in newsgroups that N bits only takes up - (N/8) bytes on most systems, and division by a factor of eight is - pretty impressive when speaking of memory. Half a megabyte given - over to a bitset (recall that there is zero space overhead for - housekeeping info; it is known at compile time exactly how large - the set is) will hold over four million bits. If you're using - those bits as status flags (e.g., - “changed”/“unchanged” flags), that's a - lot of state. -

    - You can then keep track of the “maximum bit used” - during some testing runs on representative data, make note of how - many of those bits really need to be there, and then reduce N to - a smaller number. Leave some extra space, of course. (If you - plan to write code like the incorrect example above, where the - bitset is a local variable, then you may have to talk your - compiler into allowing that much stack space; there may be zero - space overhead, but it's all allocated inside the object.) -

    - A container<bool>.   The - Committee made provision for the space savings possible with that - (N/8) usage previously mentioned, so that you don't have to do - wasteful things like Container<char> or - Container<short int>. Specifically, - vector<bool> is required to be specialized for - that space savings. -

    - The problem is that vector<bool> doesn't - behave like a normal vector anymore. There have been - journal articles which discuss the problems (the ones by Herb - Sutter in the May and July/August 1999 issues of C++ Report cover - it well). Future revisions of the ISO C++ Standard will change - the requirement for vector<bool> - specialization. In the meantime, deque<bool> - is recommended (although its behavior is sane, you probably will - not get the space savings, but the allocation scheme is different - than that of vector). -

    - Extremely weird solutions.   If - you have access to the compiler and linker at runtime, you can do - something insane, like figuring out just how many bits you need, - then writing a temporary source code file. That file contains an - instantiation of bitset for the required number of - bits, inside some wrapper functions with unchanging signatures. - Have your program then call the compiler on that file using - Position Independent Code, then open the newly-created object - file and load those wrapper functions. You'll have an - instantiation of bitset<N> for the exact - N that you need at the time. Don't forget to delete - the temporary files. (Yes, this can be, and - has been, done.) -

    - This would be the approach of either a visionary genius or a - raving lunatic, depending on your programming and management - style. Probably the latter. -

    - Which of the above techniques you use, if any, are up to you and - your intended application. Some time/space profiling is - indicated if it really matters (don't just guess). And, if you - manage to do anything along the lines of the third category, the - author would love to hear from you... -

    - Also note that the implementation of bitset used in libstdc++ has - some extensions. -

    Type String

    -

    - Bitmasks do not take char* nor const char* arguments in their - constructors. This is something of an accident, but you can read - about the problem: follow the library's “Links” from - the homepage, and from the C++ information “defect - reflector” link, select the library issues list. Issue - number 116 describes the problem. -

    - For now you can simply make a temporary string object using the - constructor expression: - 

    -      std::bitset<5> b ( std::string(“10110”) );
-

    - instead of - 

    -      std::bitset<5> b ( “10110” );    // invalid
-
    Prev Up Next
    Chapter 17. Associative Home Chapter 18. Interacting with C
    diff --git a/libstdc++-v3/doc/html/manual/bk01ix01.html b/libstdc++-v3/doc/html/manual/bk01ix01.html deleted file mode 100644 index 185b1c4bd2a..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01ix01.html +++ /dev/null @@ -1,51 +0,0 @@ - - -Index
    Index
    Prev The GNU C++ Library Next

    Index

    A

    Algorithms, - Algorithms - -
    Appendix
    Contributing, - Contributing - -
    Free Documentation, - Free Software Needs Free Documentation - -
    Porting and Maintenance, - Porting and Maintenance - -

    C

    Containers, - Containers - -

    D

    Diagnostics, - Diagnostics - -

    E

    Extensions, - Extensions - -

    I

    Input and Output, - Input and Output - -
    Introduction, - Introduction - -
    Iterators, - Iterators - -

    L

    Localization, - Localization - -

    N

    Numerics, - Numerics - -

    S

    Strings, - Strings - -
    Support, - Support - -

    T

    Test
    Exception Safety, - Qualifying Exception Safety Guarantees - -

    U

    Utilities, - Utilities - -
    Prev Up Next
    Appendix E. GNU Free Documentation License Home 
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt02.html b/libstdc++-v3/doc/html/manual/bk01pt02.html new file mode 100644 index 00000000000..b9aa00be293 --- /dev/null +++ b/libstdc++-v3/doc/html/manual/bk01pt02.html @@ -0,0 +1,46 @@ + + +Part II.  Standard Contents
    Part II.  + Standard Contents +
    Prev The GNU C++ Library Next

    Part II.  + Standard Contents +

    Table of Contents

    4. + Support + +
    Types
    Fundamental Types
    Numeric Properties
    NULL
    Dynamic Memory
    Termination
    Termination Handlers
    Verbose Terminate Handler
    5. + Diagnostics + +
    Exceptions
    API Reference
    Adding Data to exception
    Concept Checking
    6. + Utilities + +
    Functors
    Pairs
    Memory
    Allocators
    auto_ptr
    shared_ptr
    Traits
    7. + Strings + +
    String Classes
    Simple Transformations
    Case Sensitivity
    Arbitrary Character Types
    Tokenizing
    Shrink to Fit
    CString (MFC)
    8. + Localization + +
    Locales
    locale
    Facets
    ctype
    codecvt
    messages
    9. + Containers + +
    Sequences
    list
    vector
    Associative
    Insertion Hints
    bitset
    Interacting with C
    Containers vs. Arrays
    10. + Iterators + +
    Predefined
    Iterators vs. Pointers
    One Past the End
    11. + Algorithms + +
    Mutating
    swap
    12. + Numerics + +
    Complex
    complex Processing
    Generalized Operations
    Interacting with C
    Numerics vs. Arrays
    C99
    13. + Input and Output + +
    Iostream Objects
    Stream Buffers
    Derived streambuf Classes
    Buffering
    Memory Based Streams
    Compatibility With strstream
    File Based Streams
    Copying a File
    Binary Input and Output
    Interacting with C
    Using FILE* and file descriptors
    Performance
    14. + Atomics + +
    API Reference
    15. + Concurrency + +
    API Reference
    Prev Up Next
    Debugging Support Home Chapter 4.  + Support + +
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt02ch04s02.html b/libstdc++-v3/doc/html/manual/bk01pt02ch04s02.html deleted file mode 100644 index 45fa1f6e2b4..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt02ch04s02.html +++ /dev/null @@ -1,49 +0,0 @@ - - -Numeric Properties
    Numeric Properties
    Prev Chapter 4. Types Next

    Numeric Properties

    - The header limits defines - traits classes to give access to various implementation - defined-aspects of the fundamental types. The traits classes -- - fourteen in total -- are all specializations of the template class - numeric_limits, documented here - and defined as follows: - 

    -   template<typename T> 
-     struct class 
-     {
-       static const bool is_specialized;
-       static T max() throw();
-       static T min() throw();
-
-       static const int digits;
-       static const int digits10;
-       static const bool is_signed;
-       static const bool is_integer;
-       static const bool is_exact;
-       static const int radix;
-       static T epsilon() throw();
-       static T round_error() throw();
-
-       static const int min_exponent;
-       static const int min_exponent10;
-       static const int max_exponent;
-       static const int max_exponent10;
-
-       static const bool has_infinity;
-       static const bool has_quiet_NaN;
-       static const bool has_signaling_NaN;
-       static const float_denorm_style has_denorm;
-       static const bool has_denorm_loss;
-       static T infinity() throw();
-       static T quiet_NaN() throw();
-       static T denorm_min() throw();
-
-       static const bool is_iec559;
-       static const bool is_bounded;
-       static const bool is_modulo;
-
-       static const bool traps;
-       static const bool tinyness_before;
-       static const float_round_style round_style;
-     };
-
    Prev Up Next
    Chapter 4. Types Home NULL
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt02ch04s03.html b/libstdc++-v3/doc/html/manual/bk01pt02ch04s03.html deleted file mode 100644 index c9225c8b9ca..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt02ch04s03.html +++ /dev/null @@ -1,29 +0,0 @@ - - -NULL
    NULL
    Prev Chapter 4. Types Next

    NULL

    - The only change that might affect people is the type of - NULL: while it is required to be a macro, - the definition of that macro is not allowed - to be (void*)0, which is often used in C. -

    - For g++, NULL is - 

    #define

    'd to be - __null, a magic keyword extension of - g++. -

    - The biggest problem of #defining NULL to be - something like “0L” is that the compiler will view - that as a long integer before it views it as a pointer, so - overloading won't do what you expect. (This is why - g++ has a magic extension, so that - NULL is always a pointer.) -

    In his book Effective - C++, Scott Meyers points out that the best way - to solve this problem is to not overload on pointer-vs-integer - types to begin with. He also offers a way to make your own magic - NULL that will match pointers before it - matches integers. -

    See - the - Effective C++ CD example -

    Prev Up Next
    Numeric Properties Home Chapter 5. Dynamic Memory
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch08.html b/libstdc++-v3/doc/html/manual/bk01pt02ch05s02.html similarity index 61% rename from libstdc++-v3/doc/html/manual/bk01pt03ch08.html rename to libstdc++-v3/doc/html/manual/bk01pt02ch05s02.html index b66b555a2da..3487b705f00 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch08.html +++ b/libstdc++-v3/doc/html/manual/bk01pt02ch05s02.html @@ -1,9 +1,9 @@ -Chapter 8. Concept Checking
    Chapter 8. Concept Checking
    Prev Part III.  +Concept Checking
    Concept Checking
    Prev Chapter 5.  Diagnostics - Next

    Chapter 8. Concept Checking

    +

    		 Next

    Concept Checking

    In 1999, SGI added “concept checkers” to their implementation of the STL: code which checked the template parameters of instantiated pieces of the STL, in order to insure @@ -39,7 +39,10 @@ support for template parameter constraints based on concepts in the core language. This will obviate the need for the library-simulated concept checking described above. -

    Prev Up Next
    Adding Data to Exceptions Home Part IV.  +

    Prev Up Next
    Chapter 5.  + Diagnostics + + Home Chapter 6.  Utilities
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt02pr01.html b/libstdc++-v3/doc/html/manual/bk01pt02pr01.html deleted file mode 100644 index d88bbccff21..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt02pr01.html +++ /dev/null @@ -1,17 +0,0 @@ - - -
    Prev Part II.  - Support - - Next

    - This part deals with the functions called and objects created - automatically during the course of a program's existence. -

    - While we can't reproduce the contents of the Standard here (you - need to get your own copy from your nation's member body; see our - homepage for help), we can mention a couple of changes in what - kind of support a C++ program gets from the Standard Library. -

    Prev Up Next
    Part II.  - Support - - Home Chapter 4. Types
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch07s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch07s02.html deleted file mode 100644 index 54df29a6553..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch07s02.html +++ /dev/null @@ -1,20 +0,0 @@ - - -Adding Data to Exceptions
    Adding Data to Exceptions
    Prev Chapter 7. Exceptions Next

    Adding Data to Exceptions

    - The standard exception classes carry with them a single string as - data (usually describing what went wrong or where the 'throw' took - place). It's good to remember that you can add your own data to - these exceptions when extending the hierarchy: - 

    -   struct My_Exception : public std::runtime_error
-   {
-     public:
-       My_Exception (const string& whatarg)
-           : std::runtime_error(whatarg), e(errno), id(GetDataBaseID()) { }
-       int  errno_at_time_of_throw() const { return e; }
-       DBID id_of_thing_that_threw() const { return id; }
-     protected:
-       int    e;
-       DBID   id;     // some user-defined type
-   };
-
    Prev Up Next
    Chapter 7. Exceptions Home Chapter 8. Concept Checking
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch07s03.html b/libstdc++-v3/doc/html/manual/bk01pt03ch07s03.html deleted file mode 100644 index b6bbc40ea0b..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt03ch07s03.html +++ /dev/null @@ -1,4 +0,0 @@ - - -Cancellation
    Cancellation
    Prev Chapter 7. Exceptions Next

    Cancellation

    -

    Prev Up Next
    Adding Data to Exceptions Home Chapter 8. Concept Checking
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch30s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch17s02.html similarity index 92% rename from libstdc++-v3/doc/html/manual/bk01pt12ch30s02.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch17s02.html index 2605ad3b453..f2f1f483c00 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch30s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch17s02.html @@ -1,6 +1,6 @@ -Semantics
    Semantics
    Prev Chapter 30. Debug Mode Next

    Semantics

    +Semantics

    Semantics
    Prev Chapter 17. Debug Mode Next

    Semantics

    A program that uses the C++ standard library correctly will maintain the same semantics under debug mode as it had with the normal (release) library. All functional and exception-handling @@ -10,7 +10,7 @@ instance, erasing an element in a std::list is a constant-time operation in normal library, but in debug mode it is linear in the number of iterators that reference that particular - list. So while your (correct) program won't change its results, it + list. So while your (correct) program won't change its results, it is likely to execute more slowly.

    libstdc++ includes many extensions to the C++ standard library. In some cases the extensions are obvious, such as the hashed associative containers, whereas other extensions give predictable @@ -52,4 +52,4 @@ with the debug-mode checks included, but this is unsupported and not guaranteed to work. For full debug-mode support you can use the __gnu_debug::basic_string debugging container directly, which always works correctly. -

    Prev Up Next
    Chapter 30. Debug Mode Home Using
    +

    Prev Up Next
    Chapter 17. Debug Mode Home Using
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html b/libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html new file mode 100644 index 00000000000..ae2b3b830ae --- /dev/null +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch17s03.html @@ -0,0 +1,24 @@ + + +Using
    Using
    Prev Chapter 17. Debug Mode Next

    Using

    +

    Using the Debug Mode

    To use the libstdc++ debug mode, compile your application with the + compiler flag -D_GLIBCXX_DEBUG. Note that this flag + changes the sizes and behavior of standard class templates such + as std::vector, and therefore you can only link code + compiled with debug mode and code compiled without debug mode if no + instantiation of a container is passed between the two translation + units.

    By default, error messages are formatted to fit on lines of about + 78 characters. The environment variable + GLIBCXX_DEBUG_MESSAGE_LENGTH can be used to request a + different length.

    Using a Specific Debug Container

    When it is not feasible to recompile your entire application, or + only specific containers need checking, debugging containers are + available as GNU extensions. These debugging containers are + functionally equivalent to the standard drop-in containers used in + debug mode, but they are available in a separate namespace as GNU + extensions and may be used in programs compiled with either release + mode or with debug mode. The + following table provides the names and headers of the debugging + containers: +

    Table 17.1. Debugging Containers

    ContainerHeaderDebug containerDebug header
    std::bitsetbitset__gnu_debug::bitset<debug/bitset>
    std::dequedeque__gnu_debug::deque<debug/deque>
    std::listlist__gnu_debug::list<debug/list>
    std::mapmap__gnu_debug::map<debug/map>
    std::multimapmap__gnu_debug::multimap<debug/map>
    std::multisetset__gnu_debug::multiset<debug/set>
    std::setset__gnu_debug::set<debug/set>
    std::stringstring__gnu_debug::string<debug/string>
    std::wstringstring__gnu_debug::wstring<debug/string>
    std::basic_stringstring__gnu_debug::basic_string<debug/string>
    std::vectorvector__gnu_debug::vector<debug/vector>

    In addition, when compiling in C++0x mode, these additional +containers have additional debug capability. +

    Table 17.2. Debugging Containers C++0x

    ContainerHeaderDebug containerDebug header
    std::unordered_mapunordered_map__gnu_debug::unordered_map<debug/unordered_map>
    std::unordered_multimapunordered_map__gnu_debug::unordered_multimap<debug/unordered_map>
    std::unordered_setunordered_set__gnu_debug::unordered_set<debug/unordered_set>
    std::unordered_multisetunordered_set__gnu_debug::unordered_multiset<debug/unordered_set>

    Prev Up Next
    Semantics Home Design
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch30s04.html b/libstdc++-v3/doc/html/manual/bk01pt03ch17s04.html similarity index 96% rename from libstdc++-v3/doc/html/manual/bk01pt12ch30s04.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch17s04.html index 862789635a7..758af487ad7 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch30s04.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch17s04.html @@ -1,6 +1,6 @@ -Design
    Design
    Prev Chapter 30. Debug Mode Next

    Design

    +Design

    Design
    Prev Chapter 17. Debug Mode Next

    Design

    Goals

    The libstdc++ debug mode replaces unsafe (but efficient) standard containers and iterators with semantically equivalent safe standard @@ -38,7 +38,7 @@ own usability and implementation characteristics. In general, the higher-numbered conformance levels are more usable (i.e., require less recompilation) but are more complicated to implement than - the lower-numbered conformance levels. + the lower-numbered conformance levels.

    1. Full recompilation: The user must recompile his or her entire application and all C++ libraries it depends on, including the C++ standard library that ships with the @@ -101,7 +101,7 @@ container that will perform the actual work. This design decision ensures that we cannot regress release-mode performance (because the release-mode containers are left untouched) and partially - enables mixing debug and + enables mixing debug and release code at link time, although that will not be discussed at this time.

      Two types of wrappers are used in the implementation of the debug mode: container wrappers and iterator wrappers. The two types of @@ -133,8 +133,8 @@ version) as appropriate. However, all safe containers inherit from the class template __gnu_debug::_Safe_sequence, instantiated with the type of the safe container itself (an instance - of the curiously recurring template pattern).

      The iterators of a container wrapper will be - safe + of the curiously recurring template pattern).

      The iterators of a container wrapper will be + safe iterators that reference sequences of this type and wrap the iterators provided by the release-mode base class. The debugging container will use only the safe iterators within its own interface @@ -221,7 +221,7 @@ namespace std }; } // namespace std

      In debug mode we include the release-mode container (which is now -defined in in the namespace __norm) and also the +defined in the namespace __norm) and also the debug-mode container. The debug-mode container is defined within the namespace __debug, which is associated with namespace std via the C++0x namespace association language feature. This @@ -236,7 +236,7 @@ namespace std template<typename _Tp, typename _Alloc = allocator<_Tp> > class list { - // ... + // ... }; } // namespace __gnu_norm @@ -245,9 +245,9 @@ namespace std template<typename _Tp, typename _Alloc = allocator<_Tp> > class list : public __norm::list<_Tp, _Alloc>, - public __gnu_debug::_Safe_sequence<list<_Tp, _Alloc> > + public __gnu_debug::_Safe_sequence<list<_Tp, _Alloc> > { - // ... + // ... }; } // namespace __norm @@ -256,7 +256,7 @@ namespace std }

    Link- and run-time coexistence of release- and debug-mode components

    Because each component has a distinct and separate release and -debug implementation, there are are no issues with link-time +debug implementation, there is no issue with link-time coexistence: the separate namespaces result in different mangled names, and thus unique linkage.

    However, components that are defined and used within the C++ standard library itself face additional constraints. For instance, @@ -273,12 +273,12 @@ runtime errors. A simplified example of this problem is as follows. #include <string> std::string test02(); - + std::string test01() { return test02(); } - + int main() { test01(); @@ -286,7 +286,7 @@ int main() }

    ... and linked to this translation unit, compiled in release mode:

     #include <string>
- 
+
 std::string
 test02()
 {
@@ -349,7 +349,7 @@ test02()
       enticing option, because it would eliminate the need for
       the link_name extension by aliasing the
       templates. However, there is no true template aliasing mechanism
-      is C++, because both using directives and using
+      in C++, because both using directives and using
       declarations disallow specialization. This method fails
       the correctness criteria.
  •  Use implementation-specific properties of anonymous
     namespaces. 
@@ -375,7 +375,7 @@ test02()
     include ordering. Two, ODR issues remained with container member
     functions taking no arguments in mixed-mode settings resulting in
     equivalent link names,  vector::push_back()  being
-    one example. 
+    one example.
     See link
     name

    • Other options may exist for implementing the debug mode, many of which have probably been considered and others that may still be @@ -409,4 +409,4 @@ test02() a full debug-mode implementation (including debugging for CodeWarrior extensions) and is easy to use, although it meets only the "Full recompilation" (1) recompilation - guarantee.

    Prev Up Next
    Using Home Chapter 31. Parallel Mode
    + guarantee.

    Prev Up Next
    Using Home Chapter 18. Parallel Mode
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch31s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch18s02.html similarity index 82% rename from libstdc++-v3/doc/html/manual/bk01pt12ch31s02.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch18s02.html index 64acc0aa5c3..29f7dad3cca 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch31s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch18s02.html @@ -1,6 +1,6 @@ -Semantics
    Semantics
    Prev Chapter 31. Parallel Mode Next

    Semantics

    The parallel mode STL algorithms are currently not exception-safe, +Semantics

    Semantics
    Prev Chapter 18. Parallel Mode Next

    Semantics

    The parallel mode STL algorithms are currently not exception-safe, i.e. user-defined functors must not throw exceptions. Also, the order of execution is not guaranteed for some functions, of course. Therefore, user-defined functors should not have any concurrent side effects. @@ -8,4 +8,4 @@ Therefore, user-defined functors should not have any concurrent side effects. OpenMP parallel regions in concurrent threads, it is not possible to call parallel STL algorithm in concurrent threads, either. -It might work with other compilers, though.

    Prev Up Next
    Chapter 31. Parallel Mode Home Using
    +It might work with other compilers, though.

    Prev Up Next
    Chapter 18. Parallel Mode Home Using
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch31s03.html b/libstdc++-v3/doc/html/manual/bk01pt03ch18s03.html similarity index 95% rename from libstdc++-v3/doc/html/manual/bk01pt12ch31s03.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch18s03.html index 45d01b93b99..778d35acbcd 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch31s03.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch18s03.html @@ -1,13 +1,13 @@ -Using
    Using
    Prev Chapter 31. Parallel Mode Next

    Using

    Prerequisite Compiler Flags

    +Using

    Using
    Prev Chapter 18. Parallel Mode Next

    Using

    Prerequisite Compiler Flags

    Any use of parallel functionality requires additional compiler and runtime support, in particular support for OpenMP. Adding this support is not difficult: just compile your application with the compiler flag -fopenmp. This will link in libgomp, the GNU OpenMP implementation, - whose presence is mandatory. + whose presence is mandatory.

    In addition, hardware that supports atomic operations and a compiler capable of producing atomic operations is mandatory: GCC defaults to no @@ -63,4 +63,4 @@ Then compile this code with the prerequisite compiler flags flags for atomic operations.)

    The following table provides the names and headers of all the parallel algorithms that can be used in a similar manner: -

    Table 31.1. Parallel Algorithms

    AlgorithmHeaderParallel algorithmParallel header
    std::accumulatenumeric__gnu_parallel::accumulateparallel/numeric
    std::adjacent_differencenumeric__gnu_parallel::adjacent_differenceparallel/numeric
    std::inner_productnumeric__gnu_parallel::inner_productparallel/numeric
    std::partial_sumnumeric__gnu_parallel::partial_sumparallel/numeric
    std::adjacent_findalgorithm__gnu_parallel::adjacent_findparallel/algorithm
    std::countalgorithm__gnu_parallel::countparallel/algorithm
    std::count_ifalgorithm__gnu_parallel::count_ifparallel/algorithm
    std::equalalgorithm__gnu_parallel::equalparallel/algorithm
    std::findalgorithm__gnu_parallel::findparallel/algorithm
    std::find_ifalgorithm__gnu_parallel::find_ifparallel/algorithm
    std::find_first_ofalgorithm__gnu_parallel::find_first_ofparallel/algorithm
    std::for_eachalgorithm__gnu_parallel::for_eachparallel/algorithm
    std::generatealgorithm__gnu_parallel::generateparallel/algorithm
    std::generate_nalgorithm__gnu_parallel::generate_nparallel/algorithm
    std::lexicographical_comparealgorithm__gnu_parallel::lexicographical_compareparallel/algorithm
    std::mismatchalgorithm__gnu_parallel::mismatchparallel/algorithm
    std::searchalgorithm__gnu_parallel::searchparallel/algorithm
    std::search_nalgorithm__gnu_parallel::search_nparallel/algorithm
    std::transformalgorithm__gnu_parallel::transformparallel/algorithm
    std::replacealgorithm__gnu_parallel::replaceparallel/algorithm
    std::replace_ifalgorithm__gnu_parallel::replace_ifparallel/algorithm
    std::max_elementalgorithm__gnu_parallel::max_elementparallel/algorithm
    std::mergealgorithm__gnu_parallel::mergeparallel/algorithm
    std::min_elementalgorithm__gnu_parallel::min_elementparallel/algorithm
    std::nth_elementalgorithm__gnu_parallel::nth_elementparallel/algorithm
    std::partial_sortalgorithm__gnu_parallel::partial_sortparallel/algorithm
    std::partitionalgorithm__gnu_parallel::partitionparallel/algorithm
    std::random_shufflealgorithm__gnu_parallel::random_shuffleparallel/algorithm
    std::set_unionalgorithm__gnu_parallel::set_unionparallel/algorithm
    std::set_intersectionalgorithm__gnu_parallel::set_intersectionparallel/algorithm
    std::set_symmetric_differencealgorithm__gnu_parallel::set_symmetric_differenceparallel/algorithm
    std::set_differencealgorithm__gnu_parallel::set_differenceparallel/algorithm
    std::sortalgorithm__gnu_parallel::sortparallel/algorithm
    std::stable_sortalgorithm__gnu_parallel::stable_sortparallel/algorithm
    std::unique_copyalgorithm__gnu_parallel::unique_copyparallel/algorithm

    Prev Up Next
    Semantics Home Design
    +

    Table 18.1. Parallel Algorithms

    AlgorithmHeaderParallel algorithmParallel header
    std::accumulatenumeric__gnu_parallel::accumulateparallel/numeric
    std::adjacent_differencenumeric__gnu_parallel::adjacent_differenceparallel/numeric
    std::inner_productnumeric__gnu_parallel::inner_productparallel/numeric
    std::partial_sumnumeric__gnu_parallel::partial_sumparallel/numeric
    std::adjacent_findalgorithm__gnu_parallel::adjacent_findparallel/algorithm
    std::countalgorithm__gnu_parallel::countparallel/algorithm
    std::count_ifalgorithm__gnu_parallel::count_ifparallel/algorithm
    std::equalalgorithm__gnu_parallel::equalparallel/algorithm
    std::findalgorithm__gnu_parallel::findparallel/algorithm
    std::find_ifalgorithm__gnu_parallel::find_ifparallel/algorithm
    std::find_first_ofalgorithm__gnu_parallel::find_first_ofparallel/algorithm
    std::for_eachalgorithm__gnu_parallel::for_eachparallel/algorithm
    std::generatealgorithm__gnu_parallel::generateparallel/algorithm
    std::generate_nalgorithm__gnu_parallel::generate_nparallel/algorithm
    std::lexicographical_comparealgorithm__gnu_parallel::lexicographical_compareparallel/algorithm
    std::mismatchalgorithm__gnu_parallel::mismatchparallel/algorithm
    std::searchalgorithm__gnu_parallel::searchparallel/algorithm
    std::search_nalgorithm__gnu_parallel::search_nparallel/algorithm
    std::transformalgorithm__gnu_parallel::transformparallel/algorithm
    std::replacealgorithm__gnu_parallel::replaceparallel/algorithm
    std::replace_ifalgorithm__gnu_parallel::replace_ifparallel/algorithm
    std::max_elementalgorithm__gnu_parallel::max_elementparallel/algorithm
    std::mergealgorithm__gnu_parallel::mergeparallel/algorithm
    std::min_elementalgorithm__gnu_parallel::min_elementparallel/algorithm
    std::nth_elementalgorithm__gnu_parallel::nth_elementparallel/algorithm
    std::partial_sortalgorithm__gnu_parallel::partial_sortparallel/algorithm
    std::partitionalgorithm__gnu_parallel::partitionparallel/algorithm
    std::random_shufflealgorithm__gnu_parallel::random_shuffleparallel/algorithm
    std::set_unionalgorithm__gnu_parallel::set_unionparallel/algorithm
    std::set_intersectionalgorithm__gnu_parallel::set_intersectionparallel/algorithm
    std::set_symmetric_differencealgorithm__gnu_parallel::set_symmetric_differenceparallel/algorithm
    std::set_differencealgorithm__gnu_parallel::set_differenceparallel/algorithm
    std::sortalgorithm__gnu_parallel::sortparallel/algorithm
    std::stable_sortalgorithm__gnu_parallel::stable_sortparallel/algorithm
    std::unique_copyalgorithm__gnu_parallel::unique_copyparallel/algorithm

    Prev Up Next
    Semantics Home Design
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch31s04.html b/libstdc++-v3/doc/html/manual/bk01pt03ch18s04.html similarity index 95% rename from libstdc++-v3/doc/html/manual/bk01pt12ch31s04.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch18s04.html index 0e5f92549a5..2b2fd27996e 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch31s04.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch18s04.html @@ -1,6 +1,6 @@ -Design
    Design
    Prev Chapter 31. Parallel Mode Next

    Design

    +Design

    Design
    Prev Chapter 18. Parallel Mode Next

    Design

    Interface Basics

    All parallel algorithms are intended to have signatures that are equivalent to the ISO C++ algorithms replaced. For instance, the @@ -105,7 +105,7 @@ For the following algorithms in general, we have __gnu_parallel::parallel_tag and __gnu_parallel::default_parallel_tag, in addition to __gnu_parallel::sequential_tag. -__gnu_parallel::default_parallel_tag chooses the default +__gnu_parallel::default_parallel_tag chooses the default algorithm at compiletime, as does omitting the tag. __gnu_parallel::parallel_tag postpones the decision to runtime (see next section). @@ -120,7 +120,7 @@ Exact and sampling are the two available splitting strategies. For the sort and stable_sort algorithms, there are several additional choices, namely __gnu_parallel::multiway_mergesort_tag, -__gnu_parallel::multiway_mergesort_exact_tag, +__gnu_parallel::multiway_mergesort_exact_tag, __gnu_parallel::multiway_mergesort_sampling_tag, __gnu_parallel::quicksort_tag, and __gnu_parallel::balanced_quicksort_tag. @@ -198,7 +198,7 @@ int main() explicitly sequential: __gnu_serial.

    Two namespaces contain the parallel mode: -std::__parallel and __gnu_parallel. +std::__parallel and __gnu_parallel.

    Parallel implementations of standard components, including template helpers to select parallelism, are defined in namespace std::__parallel. For instance, std::transform from algorithm has a parallel counterpart in @@ -210,4 +210,4 @@ __gnu_parallel.

    More information, and an organized index of types and functions related to the parallel mode on a per-namespace basis, can be found in the generated source documentation. -

    Prev Up Next
    Using Home Testing
    +

    Prev Up Next
    Using Home Testing
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch31s05.html b/libstdc++-v3/doc/html/manual/bk01pt03ch18s05.html similarity index 84% rename from libstdc++-v3/doc/html/manual/bk01pt12ch31s05.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch18s05.html index 6a10f32eea9..7a92bbaba9c 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch31s05.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch18s05.html @@ -1,9 +1,9 @@ -Testing
    Testing
    Prev Chapter 31. Parallel Mode Next

    Testing

    +Testing

    Testing
    Prev Chapter 18. Parallel Mode Next

    Testing

    Both the normal conformance and regression tests and the supplemental performance tests work. -

    +

    To run the conformance and regression tests with the parallel mode active, 

    @@ -11,7 +11,7 @@

    The log and summary files for conformance testing are in the testsuite/parallel directory. -

    +

    To run the performance tests with the parallel mode active, 

       make check-performance-parallel
@@ -23,4 +23,4 @@
     additional software dependencies than the usual bare-boned text
     file, and can be generated by using the make
     doc-performance rule in the testsuite's Makefile.
-
    Prev Up Next
    Design Home Chapter 32. Profile Mode
    +

    Prev Up Next
    Design Home Chapter 19. Profile Mode
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch32s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s02.html similarity index 86% rename from libstdc++-v3/doc/html/manual/bk01pt12ch32s02.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch19s02.html index 3d3439b1fa3..575a89dc0c2 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch32s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s02.html @@ -1,7 +1,7 @@ -Design
    Design
    Prev Chapter 32. Profile Mode Next

    Design

    -

    Table 32.1. Code Location

    Code LocationUse
    libstdc++-v3/include/std/*Preprocessor code to redirect to profile extension headers.
    libstdc++-v3/include/profile/*Profile extension public headers (map, vector, ...).
    libstdc++-v3/include/profile/impl/*Profile extension internals. Implementation files are +Design
    Design
    Prev Chapter 19. Profile Mode Next

    Design

    +

    Table 19.1. Profile Code Location

    Code LocationUse
    libstdc++-v3/include/std/*Preprocessor code to redirect to profile extension headers.
    libstdc++-v3/include/profile/*Profile extension public headers (map, vector, ...).
    libstdc++-v3/include/profile/impl/*Profile extension internals. Implementation files are only included from impl/profiler.h, which is the only file included from the public headers.

    Wrapper Model

    @@ -10,12 +10,12 @@ we use the same wrapper model as the debug mode. We subclass entities from the release version. Wherever _GLIBCXX_PROFILE is defined, the release namespace is - std::__norm, whereas the profile namespace is + std::__norm, whereas the profile namespace is std::__profile. Using plain std translates into std::__profile.

    Whenever possible, we try to wrap at the public interface level, e.g., - in unordered_set rather than in hashtable, + in unordered_set rather than in hashtable, in order not to depend on implementation.

    Mixing object files built with and without the profile mode must @@ -29,12 +29,12 @@ Instead of instrumenting every public entry and exit point, we chose to add instrumentation on demand, as needed by individual diagnostics. - The main reason is that some diagnostics require us to extract bits of + The main reason is that some diagnostics require us to extract bits of internal state that are particular only to that diagnostic. We plan to formalize this later, after we learn more about the requirements of several diagnostics.

    - All the instrumentation points can be switched on and off using + All the instrumentation points can be switched on and off using -D[_NO]_GLIBCXX_PROFILE_<diagnostic> options. With all the instrumentation calls off, there should be negligible overhead over the release version. This property is needed to support @@ -42,7 +42,7 @@ we anticipate turning most of the instrumentation off in order to prevent profiling overhead from polluting time measurements, and thus diagnostics.

    - All the instrumentation on/off compile time switches live in + All the instrumentation on/off compile time switches live in include/profile/profiler.h.

    Run Time Behavior

    For practical reasons, the instrumentation library processes the trace @@ -60,7 +60,7 @@ is destroyed, we accumulate its effect to the corresponding entry for the call stack of its constructor location.

    - For details, see + For details, see paper presented at CGO 2009.

    Analysis and Diagnostics

    @@ -71,7 +71,7 @@ The input to the analysis is a table indexed by profile type and call stack. The data type for each entry depends on the profile type.

    Cost Model

    - While it is likely that cost models become complex as we get into + While it is likely that cost models become complex as we get into more sophisticated analysis, we will try to follow a simple set of rules at the beginning.

    • Relative benefit estimation: @@ -95,7 +95,7 @@ and report the one that performs best for each call context.

    • Show stoppers: We may decide that the presence of an operation nullifies the advice. - For instance, when considering switching from set to + For instance, when considering switching from set to unordered_set, if we detect use of operator ++, we will simply not issue the advice, since this could signal that the use care require a sorted container.

    Reports

    @@ -119,4 +119,4 @@ it helps the user focus on the key problems and ignore the uninteresting ones. We created a profile directory in the test suite. Each diagnostic must come with at least two tests, one for false positives and one for false negatives. -

    Prev Up Next
    Chapter 32. Profile Mode Home Extensions for Custom Containers
    +

    Prev Up Next
    Chapter 19. Profile Mode Home Extensions for Custom Containers
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch32s03.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s03.html similarity index 80% rename from libstdc++-v3/doc/html/manual/bk01pt12ch32s03.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch19s03.html index f943e20f0e7..89c14c0a821 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch32s03.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s03.html @@ -1,10 +1,10 @@ -Extensions for Custom Containers
    Extensions for Custom Containers
    Prev Chapter 32. Profile Mode Next

    Extensions for Custom Containers

    +Extensions for Custom Containers

    Extensions for Custom Containers
    Prev Chapter 19. Profile Mode Next

    Extensions for Custom Containers

    Many large projects use their own data structures instead of the ones in the standard library. If these data structures are similar in functionality to the standard library, they can be instrumented with the same hooks that are used to instrument the standard library. The instrumentation API is exposed in file profiler.h (look for "Instrumentation hooks"). -

    Prev Up Next
    Design Home Empirical Cost Model
    +

    Prev Up Next
    Design Home Empirical Cost Model
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch32s04.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s04.html similarity index 80% rename from libstdc++-v3/doc/html/manual/bk01pt12ch32s04.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch19s04.html index 70a142871d2..64a3a19822a 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch32s04.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s04.html @@ -1,6 +1,6 @@ -Empirical Cost Model
    Empirical Cost Model
    Prev Chapter 32. Profile Mode Next

    Empirical Cost Model

    +Empirical Cost Model

    Empirical Cost Model
    Prev Chapter 19. Profile Mode Next

    Empirical Cost Model

    Currently, the cost model uses formulas with predefined relative weights for alternative containers or container implementations. For instance, iterating through a vector is X times faster than iterating through a list. @@ -15,4 +15,4 @@ filled in either by hand or by an automated training mechanism. The analysis module will then use this database instead of the built in. generic parameters. -

    Prev Up Next
    Extensions for Custom Containers Home Implementation Issues
    +

    Prev Up Next
    Extensions for Custom Containers Home Implementation Issues
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch32s05.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s05.html similarity index 88% rename from libstdc++-v3/doc/html/manual/bk01pt12ch32s05.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch19s05.html index d64fd47518f..025dbb12679 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch32s05.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s05.html @@ -1,6 +1,6 @@ -Implementation Issues
    Implementation Issues
    Prev Chapter 32. Profile Mode Next

    Implementation Issues

    Stack Traces

    +Implementation Issues

    Implementation Issues
    Prev Chapter 19. Profile Mode Next

    Implementation Issues

    Stack Traces

    Accurate stack traces are needed during profiling since we group events by call context and dynamic instance. Without accurate traces, diagnostics may be hard to interpret. For instance, when giving advice to the user @@ -24,15 +24,15 @@ During profiling, we keep a single information table per diagnostic. There is a single lock per information table.

    Using the Standard Library in the Instrumentation Implementation

    - As much as we would like to avoid uses of stdlibc++ within our - instrumentation library, containers such as unordered_map are very - appealing. We plan to use them as long as they are named properly + As much as we would like to avoid uses of libstdc++ within our + instrumentation library, containers such as unordered_map are very + appealing. We plan to use them as long as they are named properly to avoid ambiguity.

    Malloc Hooks

    User applications/libraries can provide malloc hooks. When the implementation of the malloc hooks uses stdlibc++, there can be an infinite cycle between the profile mode instrumentation and the - the malloc hook code. + malloc hook code.

    We protect against reentrance to the profile mode instrumentation code, which should avoid this problem in most cases. @@ -46,6 +46,6 @@ The profiling library state is initialized at the first call to a profiling method. This allows us to record the construction of all global objects. However, we cannot do the same at destruction time. The trace is written - by a function registered by atexit, thus invoked by + by a function registered by atexit, thus invoked by exit. -

    Prev Up Next
    Empirical Cost Model Home Developer Information
    +

    Prev Up Next
    Empirical Cost Model Home Developer Information
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch32s06.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s06.html similarity index 89% rename from libstdc++-v3/doc/html/manual/bk01pt12ch32s06.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch19s06.html index ec752d398de..a4eb97333e8 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch32s06.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s06.html @@ -1,21 +1,21 @@ -Developer Information
    Developer Information
    Prev Chapter 32. Profile Mode Next

    Developer Information

    Big Picture

    The profile mode headers are included with - -D_GLIBCXX_PROFILE through preprocessor directives in +Developer Information

    Developer Information
    Prev Chapter 19. Profile Mode Next

    Developer Information

    Big Picture

    The profile mode headers are included with + -D_GLIBCXX_PROFILE through preprocessor directives in include/std/*. -

    Instrumented implementations are provided in +

    Instrumented implementations are provided in include/profile/*. All instrumentation hooks are macros defined in include/profile/profiler.h. -

    All the implementation of the instrumentation hooks is in +

    All the implementation of the instrumentation hooks is in include/profile/impl/*. Although all the code gets included, thus is publicly visible, only a small number of functions are called from outside this directory. All calls to hook implementations must be done through macros defined in profiler.h. The macro - must ensure (1) that the call is guarded against reentrance and + must ensure (1) that the call is guarded against reentrance and (2) that the call can be turned off at compile time using a -D_GLIBCXX_PROFILE_... compiler option.

    How To Add A Diagnostic

    Let's say the diagnostic name is "magic". -

    If you need to instrument a header not already under +

    If you need to instrument a header not already under include/profile/*, first edit the corresponding header under include/std/ and add a preprocessor directive such as the one in include/std/vector: @@ -57,7 +57,7 @@ Define class __magic_stack_info: public __magic_info. This defines the content of a line in the stack table.

  • - Define class __trace_magic: public __trace_base<__magic_info, + Define class __trace_magic: public __trace_base<__magic_info, __magic_stack_info>. It defines the content of the trace associated with this diagnostic.

    • @@ -65,4 +65,4 @@ include/profile/impl/profiler_trace.h. Use __trace_vector_to_list as an example.

    Add documentation in file doc/xml/manual/profile_mode.xml. -

    Prev Up Next
    Implementation Issues Home Diagnostics
    +

    Prev Up Next
    Implementation Issues Home Diagnostics
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch32s07.html b/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html similarity index 94% rename from libstdc++-v3/doc/html/manual/bk01pt12ch32s07.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html index 390d5665ebc..e5d00f5a9d9 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch32s07.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch19s07.html @@ -1,12 +1,12 @@ -Diagnostics
    Diagnostics
    Prev Chapter 32. Profile Mode Next

    Diagnostics

    +Diagnostics

    Diagnostics
    Prev Chapter 19. Profile Mode Next

    Diagnostics

    The table below presents all the diagnostics we intend to implement. Each diagnostic has a corresponding compile time switch -D_GLIBCXX_PROFILE_<diagnostic>. Groups of related diagnostics can be turned on with a single switch. For instance, -D_GLIBCXX_PROFILE_LOCALITY is equivalent to - -D_GLIBCXX_PROFILE_SOFTWARE_PREFETCH + -D_GLIBCXX_PROFILE_SOFTWARE_PREFETCH -D_GLIBCXX_PROFILE_RBTREE_LOCALITY.

    The benefit, cost, expected frequency and accuracy of each diagnostic @@ -18,7 +18,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. -

    Table 32.2. Diagnostics

    GroupFlagBenefitCostFreq.Implemented
    +

    Table 19.2. Profile Diagnostics

    GroupFlagBenefitCostFreq.Implemented 
    CONTAINERS HASHTABLE_TOO_SMALL101 10yes
      HASHTABLE_TOO_LARGE51 10yes
      @@ -57,22 +57,22 @@ advice sample _GLIBCXX_PROFILE_CONTAINERS.

    Hashtable Too Small

    • Switch: _GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL. -

    • Goal: Detect hashtables with many +

    • Goal: Detect hashtables with many rehash operations, small construction size and large destruction size.

    • Fundamentals: Rehash is very expensive. Read content, follow chains within bucket, evaluate hash function, place at new location in different order.

    • Sample runtime reduction: 36%. Code similar to example below. -

    • Recommendation: +

    • Recommendation: Set initial size to N at construction site S. -

    • To instrument: +

    • To instrument: unordered_set, unordered_map constructor, destructor, rehash.

    • Analysis: For each dynamic instance of unordered_[multi]set|map, record initial size and call context of the constructor. Record size increase, if any, after each relevant operation such as insert. Record the estimated rehash cost.

    • Cost model: - Number of individual rehash operations * cost per rehash.

    • Example: + Number of individual rehash operations * cost per rehash.

    • Example: 

       1 unordered_set<int> us;
 2 for (int k = 0; k < 1000000; ++k) {
@@ -89,16 +89,16 @@ foo.cc:1: advice: Changing initial unordered_set size from 10 to 1000000 saves 1

    • Fundamentals: Save memory, which is good in itself and may also improve memory reference performance through fewer cache and TLB misses.

    • Sample runtime reduction: unknown. -

    • Recommendation: +

    • Recommendation: Set initial size to N at construction site S. -

    • To instrument: +

    • To instrument: unordered_set, unordered_map constructor, destructor, rehash.

    • Analysis: For each dynamic instance of unordered_[multi]set|map, record initial size and call context of the constructor, and correlate it with its size at destruction time.

    • Cost model: - Number of iteration operations + memory saved.

    • Example: + Number of iteration operations + memory saved.

    • Example: 

       1 vector<unordered_set<int>> v(100000, unordered_set<int>(100)) ;
 2 for (int k = 0; k < 100000; ++k) {
@@ -114,7 +114,7 @@ bytes of memory and M iteration steps.
   _GLIBCXX_PROFILE_INEFFICIENT_HASH.

    • Goal: Detect hashtables with polarized distribution. -

    • Fundamentals: A non-uniform +

    • Fundamentals: A non-uniform distribution may lead to long chains, thus possibly increasing complexity by a factor up to the number of elements.

    • Sample runtime reduction: factor up @@ -128,7 +128,7 @@ bytes of memory and M iteration steps.

    • Analysis: Count the exact number of link traversals.

    • Cost model: - Total number of links traversed.

    • Example: + Total number of links traversed.

    • Example: 

       class dumb_hash {
  public:
@@ -143,7 +143,7 @@ class dumb_hash {

    Vector Too Small

    • Switch: _GLIBCXX_PROFILE_VECTOR_TOO_SMALL. -

    • Goal:Detect vectors with many +

    • Goal:Detect vectors with many resize operations, small construction size and large destruction size..

    • Fundamentals:Resizing can be expensive. Copying large amounts of data takes time. Resizing many small vectors may @@ -153,17 +153,17 @@ class dumb_hash {

    • Analysis: For each dynamic instance of vector, record initial size and call context of the constructor. - Record size increase, if any, after each relevant operation such as + Record size increase, if any, after each relevant operation such as push_back. Record the estimated resize cost.

    • Cost model: - Total number of words copied * time to copy a word.

    • Example: + Total number of words copied * time to copy a word.

    • Example: 

       1 vector<int> v;
 2 for (int k = 0; k < 1000000; ++k) {
 3   v.push_back(k);
 4 }
 
-foo.cc:1: advice: Changing initial vector size from 10 to 1000000 saves 
+foo.cc:1: advice: Changing initial vector size from 10 to 1000000 saves
 copying 4000000 bytes and 20 memory allocations and deallocations.

    Vector Too Large

    • Switch: @@ -180,7 +180,7 @@ copying 4000000 bytes and 20 memory allocations and deallocations. For each dynamic instance of vector, record initial size and call context of the constructor, and correlate it with its size at destruction time.

    • Cost model: - Total amount of memory saved.

    • Example: + Total amount of memory saved.

    • Example: 

       1 vector<vector<int>> v(100000, vector<int>(100)) ;
 2 for (int k = 0; k < 100000; ++k) {
@@ -194,20 +194,20 @@ bytes of memory and may reduce the number of cache and TLB misses.

    Vector to Hashtable

    • Switch: _GLIBCXX_PROFILE_VECTOR_TO_HASHTABLE. -

    • Goal: Detect uses of +

    • Goal: Detect uses of vector that can be substituted with unordered_set to reduce execution time.

    • Fundamentals: Linear search in a vector is very expensive, whereas searching in a hashtable is very quick.

    • Sample runtime reduction:factor up to container size. -

    • Recommendation:Replace +

    • Recommendation:Replace vector with unordered_set at site S.

    • To instrument:vector operations and access methods.

    • Analysis: For each dynamic instance of vector, record call context of the constructor. Issue the advice only if the - only methods called on this vector are push_back, + only methods called on this vector are push_back, insert and find.

    • Cost model: Cost(vector::push_back) + cost(vector::insert) + cost(find, vector) - @@ -225,18 +225,18 @@ comparisons.

    Hashtable to Vector

    • Switch: _GLIBCXX_PROFILE_HASHTABLE_TO_VECTOR. -

    • Goal: Detect uses of +

    • Goal: Detect uses of unordered_set that can be substituted with vector to reduce execution time.

    • Fundamentals: Hashtable iterator is slower than vector iterator.

    • Sample runtime reduction:95%. -

    • Recommendation:Replace +

    • Recommendation:Replace unordered_set with vector at site S.

    • To instrument:unordered_set operations and access methods.

    • Analysis: For each dynamic instance of unordered_set, record call context of the constructor. Issue the advice only if the - number of find, insert and [] + number of find, insert and [] operations on this unordered_set are small relative to the number of elements, and methods begin or end are invoked (suggesting iteration).

    • Cost model: @@ -254,11 +254,11 @@ indirections and may achieve better data locality.

    Vector to List

    • Switch: _GLIBCXX_PROFILE_VECTOR_TO_LIST. -

    • Goal: Detect cases where +

    • Goal: Detect cases where vector could be substituted with list for better performance.

    • Fundamentals: - Inserting in the middle of a vector is expensive compared to inserting in a + Inserting in the middle of a vector is expensive compared to inserting in a list.

    • Sample runtime reduction:factor up to container size. @@ -272,19 +272,19 @@ indirections and may achieve better data locality.

    • Cost model: (Sum(cost(vector::method)) - Sum(cost(list::method)), for method in [push_back, insert, erase]) - + (Cost(iterate vector) - Cost(iterate list))

    • Example: + + (Cost(iterate vector) - Cost(iterate list))

    • Example: 

       1  vector<int> v;
 2  for (int i = 0; i < 10000; ++i) {
 3    v.insert(v.begin(), i);
 4  }
 
-foo.cc:1: advice: Changing "vector" to "list" will save about 5,000,000 
+foo.cc:1: advice: Changing "vector" to "list" will save about 5,000,000
 operations.

    List to Vector

    • Switch: _GLIBCXX_PROFILE_LIST_TO_VECTOR. -

    • Goal: Detect cases where +

    • Goal: Detect cases where list could be substituted with vector for better performance.

    • Fundamentals: @@ -297,7 +297,7 @@ operations.

    • Cost model: (Sum(cost(vector::method)) - Sum(cost(list::method)), for method in [push_back, insert, erase]) - + (Cost(iterate vector) - Cost(iterate list))

    • Example: + + (Cost(iterate vector) - Cost(iterate list))

    • Example: 

       1  list<int> l;
 ...
@@ -311,7 +311,7 @@ memory references.

    List to Forward List (Slist)

    • Switch: _GLIBCXX_PROFILE_LIST_TO_SLIST. -

    • Goal: Detect cases where +

    • Goal: Detect cases where list could be substituted with forward_list for better performance.

    • Fundamentals: @@ -328,7 +328,7 @@ memory references. Issue the advice if there are no backwards traversals or insertion before a given node.

    • Cost model: - Always true.

    • Example: + Always true.

    • Example: 

       1  list<int> l;
 ...
@@ -344,7 +344,7 @@ foo.cc:1: advice: Change "list" to "forward_list".

    • Goal: Detect cases where ordered associative containers can be replaced with unordered ones.

    • Fundamentals: - Insert and search are quicker in a hashtable than in + Insert and search are quicker in a hashtable than in a red-black tree.

    • Sample runtime reduction:52%.

    • Recommendation: Replace set with unordered_set at site S.

    • To instrument: @@ -374,9 +374,9 @@ foo.cc:1: advice: Change "list" to "forward_list". performance based on actual input. For instance, advise Radix Sort over Quick Sort for a particular call context.

    • Fundamentals: - See papers: + See papers: - A framework for adaptive algorithm selection in STAPL and + A framework for adaptive algorithm selection in STAPL and Optimizing Sorting with Machine Learning Algorithms.

    • Sample runtime reduction:60%. @@ -384,7 +384,7 @@ foo.cc:1: advice: Change "list" to "forward_list". at site S from X Sort to Y Sort.

    • To instrument: sort algorithm.

    • Analysis: Issue the advice if the cost model tells us that another sort algorithm - would do better on this input. Requires us to know what algorithm we + would do better on this input. Requires us to know what algorithm we are using in our sort implementation in release mode.

    • Cost model: Runtime(algo) for algo in [radix, quick, merge, ...]

    • Example: 

      @@ -399,13 +399,13 @@ foo.cc:1: advice: Change "list" to "forward_list".

    • Fundamentals: Indirect references are hard to predict and are very expensive when they miss in caches.

    • Sample runtime reduction:25%. -

    • Recommendation: Insert prefetch +

    • Recommendation: Insert prefetch instruction.

    • To instrument: Vector iterator and access operator [].

    • Analysis: First, get cache line size and page size from system. Then record iterator dereference sequences for which the value is a pointer. - For each sequence within a container, issue a warning if successive pointer + For each sequence within a container, issue a warning if successive pointer addresses are not within cache lines and do not form a linear pattern (otherwise they may be prefetched by hardware). If they also step across page boundaries, make the warning stronger. @@ -417,11 +417,11 @@ foo.cc:1: advice: Change "list" to "forward_list".

      This analysis is a little oversimplified. A better cost model could be created by understanding the capability of the hardware prefetcher. - This model could be trained automatically by running a set of synthetic + This model could be trained automatically by running a set of synthetic cases.

    • Cost model: Total distance between pointer values of successive elements in vectors - of pointers.

    • Example: + of pointers.

    • Example: 

       1 int zero = 0;
 2 vector<int*> v(10000000, &zero);
@@ -441,14 +441,14 @@ foo.cc:7: advice: Insert prefetch instruction.
   with respect to their actual traversal patterns.

    • Fundamentals:Allocation can be tuned to a specific traversal pattern, to result in better data locality. - See paper: + See paper: Custom Memory Allocation for Free.

    • Sample runtime reduction:30%.

    • Recommendation: High scatter score N for container built at site S. Consider changing allocation sequence or choosing a structure conscious - allocator.

    • To instrument: Methods of all + allocator.

    • To instrument: Methods of all containers using linked structures.

    • Analysis: First, get cache line size and page size from system. Then record the number of successive elements that are on different line @@ -502,7 +502,7 @@ the allocation sequence or switching to a structure conscious allocator. container member accesses. Issue advice for elements referenced by multiple threads. See paper: - The LRPD test: speculative run-time parallelization of loops with + The LRPD test: speculative run-time parallelization of loops with privatization and reduction parallelization.

    • Cost model: Number of accesses to elements referenced from multiple threads @@ -512,7 +512,7 @@ the allocation sequence or switching to a structure conscious allocator.

    False Sharing

    • Switch: _GLIBCXX_PROFILE_FALSE_SHARING.

    • Goal: Detect elements in the - same container which share a cache line, are written by at least one + same container which share a cache line, are written by at least one thread, and accessed by different threads.

    • Fundamentals: Under these assumptions, cache protocols require @@ -523,14 +523,14 @@ the allocation sequence or switching to a structure conscious allocator. and iterators.

    • Analysis: First, get the cache line size. - For each shared container, record all the associated iterator dereferences + For each shared container, record all the associated iterator dereferences and member access methods with the thread id. Compare the address lists - across threads to detect references in two different threads to the same - cache line. Issue a warning only if the ratio to total references is - significant. Do the same for iterator dereference values if they are + across threads to detect references in two different threads to the same + cache line. Issue a warning only if the ratio to total references is + significant. Do the same for iterator dereference values if they are pointers.

    • Cost model: Number of accesses to same cache line from different threads. -

    • Example: +

    • Example: 

       1     vector<int> v(2, 0);
 2 #pragma omp parallel for shared(v, SIZE) schedule(static, 1)
@@ -539,7 +539,7 @@ the allocation sequence or switching to a structure conscious allocator.
 5     }
 
 OMP_NUM_THREADS=2 ./a.out
-foo.cc:1: advice: Change container structure or padding to avoid false 
+foo.cc:1: advice: Change container structure or padding to avoid false
 sharing in multithreaded access at foo.cc:4.  Detected N shared cache lines.

    Statistics

    @@ -555,4 +555,4 @@ sharing in multithreaded access at foo.cc:4. Detected N shared cache lines. This diagnostic will not issue any advice, but it will print statistics for each container construction site. The statistics will contain the cost of each operation actually performed on the container. -

    Prev Up Next
    Developer Information Home Chapter 33. Allocators
    +

    Prev Up Next
    Developer Information Home Chapter 20. Allocators
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch34s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html similarity index 89% rename from libstdc++-v3/doc/html/manual/bk01pt12ch34s02.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html index 70e4d924cec..185d3ad8df4 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch34s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch21s02.html @@ -1,6 +1,6 @@ -HP/SGI
    HP/SGI
    Prev Chapter 34. Containers Next

    HP/SGI

    +HP/SGI

    HP/SGI
    Prev Chapter 21. Containers Next

    HP/SGI

    A few extensions and nods to backwards-compatibility have been made with containers. Those dealing with older SGI-style allocators are dealt with elsewhere. The remaining ones all deal with bits: @@ -26,7 +26,7 @@

    Note that these may in fact be removed in the future, although we have no present plans to do so (and there doesn't seem to be any immediate reason to). -

    The semantics of member function operator[] are not specified +

    The semantics of member function operator[] are not specified in the C++ standard. A long-standing defect report calls for sensible obvious semantics, which are already implemented here: op[] on a const bitset returns a bool, and for a non-const bitset returns a @@ -40,4 +40,4 @@ 

        size_t _Find_first() const;
    size_t _Find_next (size_t prev) const;

    The same caveat given for the _Unchecked_* functions applies here also. -

    Prev Up Next
    Chapter 34. Containers Home Deprecated HP/SGI
    +

    Prev Up Next
    Chapter 21. Containers Home Deprecated HP/SGI
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch34s03.html b/libstdc++-v3/doc/html/manual/bk01pt03ch21s03.html similarity index 92% rename from libstdc++-v3/doc/html/manual/bk01pt12ch34s03.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch21s03.html index b9f0849bf5a..7486167b089 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch34s03.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch21s03.html @@ -1,6 +1,6 @@ -Deprecated HP/SGI
    Deprecated HP/SGI
    Prev Chapter 34. Containers Next

    Deprecated HP/SGI

    +Deprecated HP/SGI

    Deprecated HP/SGI
    Prev Chapter 21. Containers Next

    Deprecated HP/SGI

    The SGI hashing classes hash_set and hash_set have been deprecated by the unordered_set, unordered_multiset, unordered_map, @@ -47,4 +47,4 @@ possibility of pathological cases, you'll probably get better performance from hash_map. -

    Prev Up Next
    HP/SGI Home Chapter 35. Utilities
    +

    Prev Up Next
    HP/SGI Home Chapter 22. Utilities
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch41s02.html b/libstdc++-v3/doc/html/manual/bk01pt03ch28s02.html similarity index 92% rename from libstdc++-v3/doc/html/manual/bk01pt12ch41s02.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch28s02.html index 6dee3ae2abb..ec4a92763c4 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch41s02.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch28s02.html @@ -1,6 +1,6 @@ -Implementation
    Implementation
    Prev Chapter 41. Concurrency Next

    Implementation

    Using Builtin Atomic Functions

    The functions for atomic operations described above are either +Implementation

    Implementation
    Prev Chapter 28. Concurrency Next

    Implementation

    Using Builtin Atomic Functions

    The functions for atomic operations described above are either implemented via compiler intrinsics (if the underlying host is capable) or by library fallbacks.

    Compiler intrinsics (builtins) are always preferred. However, as the compiler builtins for atomics are not universally implemented, @@ -12,7 +12,7 @@ missing reference to __sync_fetch_and_add_4.) conditionally, via the -march command line flag. This makes usage vary depending on the target hardware and the flags used during compile. -

    +

    If builtins are possible for bool-sized integral types, _GLIBCXX_ATOMIC_BUILTINS_1 will be defined. If builtins are possible for int-sized integral types, @@ -38,4 +38,4 @@ use this layer. More detail as to the specific interface can be found in the sou functions, and usage found in the usual <pthread.h> file, including pthread_t, pthread_once_t, pthread_create, etc. -

    Prev Up Next
    Chapter 41. Concurrency Home Use
    +

    Prev Up Next
    Chapter 28. Concurrency Home Use
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch41s03.html b/libstdc++-v3/doc/html/manual/bk01pt03ch28s03.html similarity index 63% rename from libstdc++-v3/doc/html/manual/bk01pt12ch41s03.html rename to libstdc++-v3/doc/html/manual/bk01pt03ch28s03.html index deb28ca2ca4..e5835a70b76 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch41s03.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03ch28s03.html @@ -1,6 +1,6 @@ -Use
    Use
    Prev Chapter 41. Concurrency Next

    Use

    Typical usage of the last two constructs is demonstrated as follows: +Use

    Use
    Prev Chapter 28. Concurrency Next

    Use

    Typical usage of the last two constructs is demonstrated as follows: 

     #include <ext/concurrence.h>
 
@@ -31,7 +31,6 @@ the mutex as control moves out of this block.
 concurrence-related errors. These classes
 are: __concurrence_lock_error, __concurrence_unlock_error, __concurrence_wait_error,
 and __concurrence_broadcast_error.
-
    Prev Up Next
    Implementation Home Appendix A.  - Contributing - +

    Prev Up Next
    Implementation Home Part IV.  + Appendices
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12pr03.html b/libstdc++-v3/doc/html/manual/bk01pt03pr01.html similarity index 81% rename from libstdc++-v3/doc/html/manual/bk01pt12pr03.html rename to libstdc++-v3/doc/html/manual/bk01pt03pr01.html index a3af7c689c3..be1c0f16ae2 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt12pr03.html +++ b/libstdc++-v3/doc/html/manual/bk01pt03pr01.html @@ -1,26 +1,26 @@ -
    Prev Part XII.  +
    Prev Part III.  Extensions - Next

    +

    		 Next

    Here we will make an attempt at describing the non-Standard extensions to the library. Some of these are from SGI's STL, some of these are GNU's, and some just seemed to appear on the doorstep.

    Before you leap in and use any of these extensions, be aware of two things:

    1. - Non-Standard means exactly that. + Non-Standard means exactly that.

      The behavior, and the very existence, of these extensions may change with little or no warning. (Ideally, the really good ones will appear in the next revision of C++.) Also, other platforms, other compilers, other versions of g++ or libstdc++ may not recognize these names, or - treat them differently, or... + treat them differently, or...

    2. - You should know how to access these headers properly. -

    Prev Up Next
    Part XII.  + You should know how to access these headers properly. +

    Prev Up Next
    Part III.  Extensions - Home Chapter 29. Compile Time Checks
    +     		Home Chapter 16. Compile Time Checks
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt04.html b/libstdc++-v3/doc/html/manual/bk01pt04.html new file mode 100644 index 00000000000..66713b1213d --- /dev/null +++ b/libstdc++-v3/doc/html/manual/bk01pt04.html @@ -0,0 +1,21 @@ + + +Part IV.  Appendices
    Part IV.  + Appendices +
    Prev The GNU C++ Library Next

    Part IV.  + Appendices +

    Table of Contents

    A. + Contributing + +
    Contributor Checklist
    Reading
    Assignment
    Getting Sources
    Submitting Patches
    Directory Layout and Source Conventions
    Coding Style
    Bad Identifiers
    By Example
    Documentation Style
    Doxygen
    Docbook
    Combines
    Design Notes
    B. + Porting and Maintenance + +
    Configure and Build Hacking
    Prerequisites
    Overview: What Comes from Where
    Storing Information in non-AC files (like configure.host)
    Coding and Commenting Conventions
    The acinclude.m4 layout
    GLIBCXX_ENABLE, the --enable maker
    Porting to New Hardware or Operating Systems
    Operating System
    CPU
    Character Types
    Thread Safety
    Numeric Limits
    Libtool
    Test
    Organization
    Running the Testsuite
    Writing a new test case
    Test Harness and Utilities
    Special Topics
    ABI Policy and Guidelines
    The C++ Interface
    Versioning
    Allowed Changes
    Prohibited Changes
    Implementation
    Testing
    Outstanding Issues
    API Evolution and Deprecation History
    3.0
    3.1
    3.2
    3.3
    3.4
    4.0
    4.1
    4.2
    4.3
    4.4
    4.5
    Backwards Compatibility
    First
    Second
    Third
    C. + Free Software Needs Free Documentation + +
    D. + GNU General Public License version 3 +
    E. GNU Free Documentation License
    Prev Up Next
    Use Home Appendix A.  + Contributing + +
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt05ch13.html b/libstdc++-v3/doc/html/manual/bk01pt05ch13.html deleted file mode 100644 index e86d7fe1779..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt05ch13.html +++ /dev/null @@ -1,90 +0,0 @@ - - -Chapter 13. String Classes
    Chapter 13. String Classes
    Prev Part V.  - Strings - - Next

    Chapter 13. String Classes

    Table of Contents

    Simple Transformations
    Case Sensitivity
    Arbitrary Character Types
    Tokenizing
    Shrink to Fit
    CString (MFC)

    Simple Transformations

    - Here are Standard, simple, and portable ways to perform common - transformations on a string instance, such as - "convert to all upper case." The word transformations - is especially apt, because the standard template function - transform<> is used. -

    - This code will go through some iterations. Here's a simple - version: - 

    -   #include <string>
-   #include <algorithm>
-   #include <cctype>      // old <ctype.h>
-
-   struct ToLower
-   {
-     char operator() (char c) const  { return std::tolower(c); }
-   };
-
-   struct ToUpper
-   {
-     char operator() (char c) const  { return std::toupper(c); }
-   };
-
-   int main()
-   {
-     std::string  s ("Some Kind Of Initial Input Goes Here");
-
-     // Change everything into upper case
-     std::transform (s.begin(), s.end(), s.begin(), ToUpper());
-
-     // Change everything into lower case
-     std::transform (s.begin(), s.end(), s.begin(), ToLower());
-
-     // Change everything back into upper case, but store the
-     // result in a different string
-     std::string  capital_s;
-     capital_s.resize(s.size());
-     std::transform (s.begin(), s.end(), capital_s.begin(), ToUpper());
-   } 
-

    - Note that these calls all - involve the global C locale through the use of the C functions - toupper/tolower. This is absolutely guaranteed to work -- - but only if the string contains only characters - from the basic source character set, and there are only - 96 of those. Which means that not even all English text can be - represented (certain British spellings, proper names, and so forth). - So, if all your input forevermore consists of only those 96 - characters (hahahahahaha), then you're done. -

    Note that the - ToUpper and ToLower function objects - are needed because toupper and tolower - are overloaded names (declared in <cctype> and - <locale>) so the template-arguments for - transform<> cannot be deduced, as explained in - this - message. - - At minimum, you can write short wrappers like - 

    -   char toLower (char c)
-   {
-      return std::tolower(c);
-   }

    (Thanks to James Kanze for assistance and suggestions on all of this.) -

    Another common operation is trimming off excess whitespace. Much - like transformations, this task is trivial with the use of string's - find family. These examples are broken into multiple - statements for readability: - 

    -   std::string  str (" \t blah blah blah    \n ");
-
-   // trim leading whitespace
-   string::size_type  notwhite = str.find_first_not_of(" \t\n");
-   str.erase(0,notwhite);
-
-   // trim trailing whitespace
-   notwhite = str.find_last_not_of(" \t\n"); 
-   str.erase(notwhite+1);

    Obviously, the calls to find could be inserted directly - into the calls to erase, in case your compiler does not - optimize named temporaries out of existence. -

    Prev Up Next
    Part V.  - Strings - - Home Case Sensitivity
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt05ch13s02.html b/libstdc++-v3/doc/html/manual/bk01pt05ch13s02.html deleted file mode 100644 index 2cd970a12bf..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt05ch13s02.html +++ /dev/null @@ -1,40 +0,0 @@ - - -Case Sensitivity
    Case Sensitivity
    Prev Chapter 13. String Classes Next

    Case Sensitivity

    -

    The well-known-and-if-it-isn't-well-known-it-ought-to-be - Guru of the Week - discussions held on Usenet covered this topic in January of 1998. - Briefly, the challenge was, “write a 'ci_string' class which - is identical to the standard 'string' class, but is - case-insensitive in the same way as the (common but nonstandard) - C function stricmp()”. - 

    -   ci_string s( "AbCdE" );
-
-   // case insensitive
-   assert( s == "abcde" );
-   assert( s == "ABCDE" );
-
-   // still case-preserving, of course
-   assert( strcmp( s.c_str(), "AbCdE" ) == 0 );
-   assert( strcmp( s.c_str(), "abcde" ) != 0 );

    The solution is surprisingly easy. The original answer was - posted on Usenet, and a revised version appears in Herb Sutter's - book Exceptional C++ and on his website as GotW 29. -

    See? Told you it was easy!

    - Added June 2000: The May 2000 issue of C++ - Report contains a fascinating article by - Matt Austern (yes, the Matt Austern) on why - case-insensitive comparisons are not as easy as they seem, and - why creating a class is the wrong way to go - about it in production code. (The GotW answer mentions one of - the principle difficulties; his article mentions more.) -

    Basically, this is "easy" only if you ignore some things, - things which may be too important to your program to ignore. (I chose - to ignore them when originally writing this entry, and am surprised - that nobody ever called me on it...) The GotW question and answer - remain useful instructional tools, however. -

    Added September 2000: James Kanze provided a link to a - Unicode - Technical Report discussing case handling, which provides some - very good information. -

    Prev Up Next
    Chapter 13. String Classes Home Arbitrary Character Types
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt05ch13s03.html b/libstdc++-v3/doc/html/manual/bk01pt05ch13s03.html deleted file mode 100644 index aa2afea53a6..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt05ch13s03.html +++ /dev/null @@ -1,57 +0,0 @@ - - -Arbitrary Character Types
    Arbitrary Character Types
    Prev Chapter 13. String Classes Next

    Arbitrary Character Types

    -

    The std::basic_string is tantalizingly general, in that - it is parameterized on the type of the characters which it holds. - In theory, you could whip up a Unicode character class and instantiate - std::basic_string<my_unicode_char>, or assuming - that integers are wider than characters on your platform, maybe just - declare variables of type std::basic_string<int>. -

    That's the theory. Remember however that basic_string has additional - type parameters, which take default arguments based on the character - type (called CharT here): - 

    -      template <typename CharT,
-                typename Traits = char_traits<CharT>,
-                typename Alloc = allocator<CharT> >
-      class basic_string { .... };

    Now, allocator<CharT> will probably Do The Right - Thing by default, unless you need to implement your own allocator - for your characters. -

    But char_traits takes more work. The char_traits - template is declared but not defined. - That means there is only - 

    -      template <typename CharT>
-        struct char_traits
-        {
-            static void foo (type1 x, type2 y);
-            ...
-        };

    and functions such as char_traits<CharT>::foo() are not - actually defined anywhere for the general case. The C++ standard - permits this, because writing such a definition to fit all possible - CharT's cannot be done. -

    The C++ standard also requires that char_traits be specialized for - instantiations of char and wchar_t, and it - is these template specializations that permit entities like - basic_string<char,char_traits<char>> to work. -

    If you want to use character types other than char and wchar_t, - such as unsigned char and int, you will - need suitable specializations for them. For a time, in earlier - versions of GCC, there was a mostly-correct implementation that - let programmers be lazy but it broke under many situations, so it - was removed. GCC 3.4 introduced a new implementation that mostly - works and can be specialized even for int and other - built-in types. -

    If you want to use your own special character class, then you have - a lot - of work to do, especially if you with to use i18n features - (facets require traits information but don't have a traits argument). -

    Another example of how to specialize char_traits was given on the - mailing list and at a later date was put into the file - include/ext/pod_char_traits.h. We agree - that the way it's used with basic_string (scroll down to main()) - doesn't look nice, but that's because the - nice-looking first attempt turned out to not - be conforming C++, due to the rule that CharT must be a POD. - (See how tricky this is?) -

    Prev Up Next
    Case Sensitivity Home Tokenizing
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt05ch13s04.html b/libstdc++-v3/doc/html/manual/bk01pt05ch13s04.html deleted file mode 100644 index 12d1ee7fb5c..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt05ch13s04.html +++ /dev/null @@ -1,79 +0,0 @@ - - -Tokenizing
    Tokenizing
    Prev Chapter 13. String Classes Next

    Tokenizing

    -

    The Standard C (and C++) function strtok() leaves a lot to - be desired in terms of user-friendliness. It's unintuitive, it - destroys the character string on which it operates, and it requires - you to handle all the memory problems. But it does let the client - code decide what to use to break the string into pieces; it allows - you to choose the "whitespace," so to speak. -

    A C++ implementation lets us keep the good things and fix those - annoyances. The implementation here is more intuitive (you only - call it once, not in a loop with varying argument), it does not - affect the original string at all, and all the memory allocation - is handled for you. -

    It's called stringtok, and it's a template function. Sources are - as below, in a less-portable form than it could be, to keep this - example simple (for example, see the comments on what kind of - string it will accept). - 

    -#include <string>
-template <typename Container>
-void
-stringtok(Container &container, string const &in,
-          const char * const delimiters = " \t\n")
-{
-    const string::size_type len = in.length();
-          string::size_type i = 0;
-
-    while (i < len)
-    {
-        // Eat leading whitespace
-        i = in.find_first_not_of(delimiters, i);
-        if (i == string::npos)
-	  return;   // Nothing left but white space
-
-        // Find the end of the token
-        string::size_type j = in.find_first_of(delimiters, i);
-
-        // Push token
-        if (j == string::npos) 
-	{
-	  container.push_back(in.substr(i));
-	  return;
-        } 
-	else
-	  container.push_back(in.substr(i, j-i));
-
-        // Set up for next loop
-        i = j + 1;
-    }
-}
-

    - The author uses a more general (but less readable) form of it for - parsing command strings and the like. If you compiled and ran this - code using it: - 

    -   std::list<string>  ls;
-   stringtok (ls, " this  \t is\t\n  a test  ");
-   for (std::list<string>const_iterator i = ls.begin();
-        i != ls.end(); ++i)
-   {
-       std::cerr << ':' << (*i) << ":\n";
-   }

    You would see this as output: - 

    -   :this:
-   :is:
-   :a:
-   :test:

    with all the whitespace removed. The original s is still - available for use, ls will clean up after itself, and - ls.size() will return how many tokens there were. -

    As always, there is a price paid here, in that stringtok is not - as fast as strtok. The other benefits usually outweigh that, however. -

    Added February 2001: Mark Wilden pointed out that the - standard std::getline() function can be used with standard - istringstreams to perform - tokenizing as well. Build an istringstream from the input text, - and then use std::getline with varying delimiters (the three-argument - signature) to extract tokens into a string. -

    Prev Up Next
    Arbitrary Character Types Home Shrink to Fit
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt05ch13s05.html b/libstdc++-v3/doc/html/manual/bk01pt05ch13s05.html deleted file mode 100644 index b6a5da10d20..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt05ch13s05.html +++ /dev/null @@ -1,16 +0,0 @@ - - -Shrink to Fit
    Shrink to Fit
    Prev Chapter 13. String Classes Next

    Shrink to Fit

    -

    From GCC 3.4 calling s.reserve(res) on a - string s with res < s.capacity() will - reduce the string's capacity to std::max(s.size(), res). -

    This behaviour is suggested, but not required by the standard. Prior - to GCC 3.4 the following alternative can be used instead - 

    -      std::string(str.data(), str.size()).swap(str);
-

    This is similar to the idiom for reducing - a vector's memory usage - (see this FAQ - entry) but the regular copy constructor cannot be used - because libstdc++'s string is Copy-On-Write. -

    Prev Up Next
    Tokenizing Home CString (MFC)
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt05ch13s06.html b/libstdc++-v3/doc/html/manual/bk01pt05ch13s06.html deleted file mode 100644 index 29ad197e1dd..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt05ch13s06.html +++ /dev/null @@ -1,94 +0,0 @@ - - -CString (MFC)
    CString (MFC)
    Prev Chapter 13. String Classes Next

    CString (MFC)

    -

    A common lament seen in various newsgroups deals with the Standard - string class as opposed to the Microsoft Foundation Class called - CString. Often programmers realize that a standard portable - answer is better than a proprietary nonportable one, but in porting - their application from a Win32 platform, they discover that they - are relying on special functions offered by the CString class. -

    Things are not as bad as they seem. In - this - message, Joe Buck points out a few very important things: -

    • The Standard string supports all the operations - that CString does, with three exceptions. -

    • Two of those exceptions (whitespace trimming and case - conversion) are trivial to implement. In fact, we do so - on this page. -

    • The third is CString::Format, which allows formatting - in the style of sprintf. This deserves some mention: -

    - The old libg++ library had a function called form(), which did much - the same thing. But for a Standard solution, you should use the - stringstream classes. These are the bridge between the iostream - hierarchy and the string class, and they operate with regular - streams seamlessly because they inherit from the iostream - hierarchy. An quick example: - 

    -   #include <iostream>
-   #include <string>
-   #include <sstream>
-
-   string f (string& incoming)     // incoming is "foo  N"
-   {
-       istringstream   incoming_stream(incoming);
-       string          the_word;
-       int             the_number;
-
-       incoming_stream >> the_word        // extract "foo"
-                       >> the_number;     // extract N
-
-       ostringstream   output_stream;
-       output_stream << "The word was " << the_word
-                     << " and 3*N was " << (3*the_number);
-
-       return output_stream.str();
-   }

    A serious problem with CString is a design bug in its memory - allocation. Specifically, quoting from that same message: - 

    -   CString suffers from a common programming error that results in
-   poor performance.  Consider the following code:
-   
-   CString n_copies_of (const CString& foo, unsigned n)
-   {
-           CString tmp;
-           for (unsigned i = 0; i < n; i++)
-                   tmp += foo;
-           return tmp;
-   }
-   
-   This function is O(n^2), not O(n).  The reason is that each +=
-   causes a reallocation and copy of the existing string.  Microsoft
-   applications are full of this kind of thing (quadratic performance
-   on tasks that can be done in linear time) -- on the other hand,
-   we should be thankful, as it's created such a big market for high-end
-   ix86 hardware. :-)
-   
-   If you replace CString with string in the above function, the
-   performance is O(n).
-

    Joe Buck also pointed out some other things to keep in mind when - comparing CString and the Standard string class: -

    • CString permits access to its internal representation; coders - who exploited that may have problems moving to string. -

    • Microsoft ships the source to CString (in the files - MFC\SRC\Str{core,ex}.cpp), so you could fix the allocation - bug and rebuild your MFC libraries. - Note: It looks like the CString shipped - with VC++6.0 has fixed this, although it may in fact have been - one of the VC++ SPs that did it. -

    • string operations like this have O(n) complexity - if the implementors do it correctly. The libstdc++ - implementors did it correctly. Other vendors might not. -

    • While parts of the SGI STL are used in libstdc++, their - string class is not. The SGI string is essentially - vector<char> and does not do any reference - counting like libstdc++'s does. (It is O(n), though.) - So if you're thinking about SGI's string or rope classes, - you're now looking at four possibilities: CString, the - libstdc++ string, the SGI string, and the SGI rope, and this - is all before any allocator or traits customizations! (More - choices than you can shake a stick at -- want fries with that?) -

    Prev Up Next
    Shrink to Fit Home Part VI.  - Localization - -
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt08ch19.html b/libstdc++-v3/doc/html/manual/bk01pt08ch19.html deleted file mode 100644 index 6b6bb02dbde..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt08ch19.html +++ /dev/null @@ -1,39 +0,0 @@ - - -Chapter 19. Predefined
    Chapter 19. Predefined
    Prev Part VIII.  - Iterators - - Next

    Chapter 19. Predefined

    Table of Contents

    Iterators vs. Pointers
    One Past the End

    Iterators vs. Pointers

    - The following -FAQ entry points out that -iterators are not implemented as pointers. They are a generalization -of pointers, but they are implemented in libstdc++ as separate -classes. -

    Keeping that simple fact in mind as you design your code will - prevent a whole lot of difficult-to-understand bugs. -

    You can think of it the other way 'round, even. Since iterators - are a generalization, that means that pointers are - iterators, and that pointers can be used whenever an - iterator would be. All those functions in the Algorithms chapter - of the Standard will work just as well on plain arrays and their - pointers. -

    That doesn't mean that when you pass in a pointer, it gets wrapped - into some special delegating iterator-to-pointer class with a layer - of overhead. (If you think that's the case anywhere, you don't - understand templates to begin with...) Oh, no; if you pass - in a pointer, then the compiler will instantiate that template - using T* as a type, and good old high-speed pointer arithmetic as - its operations, so the resulting code will be doing exactly the same - things as it would be doing if you had hand-coded it yourself (for - the 273rd time). -

    How much overhead is there when using an iterator class? - Very little. Most of the layering classes contain nothing but - typedefs, and typedefs are "meta-information" that simply - tell the compiler some nicknames; they don't create code. That - information gets passed down through inheritance, so while the - compiler has to do work looking up all the names, your runtime code - does not. (This has been a prime concern from the beginning.) -

    Prev Up Next
    Part VIII.  - Iterators - - Home One Past the End
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt08ch19s02.html b/libstdc++-v3/doc/html/manual/bk01pt08ch19s02.html deleted file mode 100644 index 2a0e28d40da..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt08ch19s02.html +++ /dev/null @@ -1,86 +0,0 @@ - - -One Past the End
    One Past the End
    Prev Chapter 19. Predefined Next

    One Past the End

    This starts off sounding complicated, but is actually very easy, - especially towards the end. Trust me. -

    Beginners usually have a little trouble understand the whole - 'past-the-end' thing, until they remember their early algebra classes - (see, they told you that stuff would come in handy!) and - the concept of half-open ranges. -

    First, some history, and a reminder of some of the funkier rules in - C and C++ for builtin arrays. The following rules have always been - true for both languages: -

    1. You can point anywhere in the array, or to the first element - past the end of the array. A pointer that points to one - past the end of the array is guaranteed to be as unique as a - pointer to somewhere inside the array, so that you can compare - such pointers safely. -

    2. You can only dereference a pointer that points into an array. - If your array pointer points outside the array -- even to just - one past the end -- and you dereference it, Bad Things happen. -

    3. Strictly speaking, simply pointing anywhere else invokes - undefined behavior. Most programs won't puke until such a - pointer is actually dereferenced, but the standards leave that - up to the platform. -

    The reason this past-the-end addressing was allowed is to make it - easy to write a loop to go over an entire array, e.g., - while (*d++ = *s++);. -

    So, when you think of two pointers delimiting an array, don't think - of them as indexing 0 through n-1. Think of them as boundary - markers: - 

    -
-   beginning            end
-     |                   |
-     |                   |               This is bad.  Always having to
-     |                   |               remember to add or subtract one.
-     |                   |               Off-by-one bugs very common here.
-     V                   V
-        array of N elements
-     |---|---|--...--|---|---|
-     | 0 | 1 |  ...  |N-2|N-1|
-     |---|---|--...--|---|---|
-
-     ^                       ^
-     |                       |
-     |                       |           This is good.  This is safe.  This
-     |                       |           is guaranteed to work.  Just don't
-     |                       |           dereference 'end'.
-   beginning                end
-
-

    See? Everything between the boundary markers is part of the array. - Simple. -

    Now think back to your junior-high school algebra course, when you - were learning how to draw graphs. Remember that a graph terminating - with a solid dot meant, "Everything up through this point," - and a graph terminating with an open dot meant, "Everything up - to, but not including, this point," respectively called closed - and open ranges? Remember how closed ranges were written with - brackets, [a,b], and open ranges were written with parentheses, - (a,b)? -

    The boundary markers for arrays describe a half-open range, - starting with (and including) the first element, and ending with (but - not including) the last element: [beginning,end). See, I - told you it would be simple in the end. -

    Iterators, and everything working with iterators, follows this same - time-honored tradition. A container's begin() method returns - an iterator referring to the first element, and its end() - method returns a past-the-end iterator, which is guaranteed to be - unique and comparable against any other iterator pointing into the - middle of the container. -

    Container constructors, container methods, and algorithms, all take - pairs of iterators describing a range of values on which to operate. - All of these ranges are half-open ranges, so you pass the beginning - iterator as the starting parameter, and the one-past-the-end iterator - as the finishing parameter. -

    This generalizes very well. You can operate on sub-ranges quite - easily this way; functions accepting a [first,last) range - don't know or care whether they are the boundaries of an entire {array, - sequence, container, whatever}, or whether they only enclose a few - elements from the center. This approach also makes zero-length - sequences very simple to recognize: if the two endpoints compare - equal, then the {array, sequence, container, whatever} is empty. -

    Just don't dereference end(). -

    Prev Up Next
    Chapter 19. Predefined Home Part IX.  - Algorithms - -
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt09ch20.html b/libstdc++-v3/doc/html/manual/bk01pt09ch20.html deleted file mode 100644 index a343f9c50f4..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt09ch20.html +++ /dev/null @@ -1,19 +0,0 @@ - - -Chapter 20. Mutating
    Chapter 20. Mutating
    Prev Part IX.  - Algorithms - - Next

    Chapter 20. Mutating

    Table of Contents

    swap
    Specializations

    swap

    Specializations

    If you call std::swap(x,y); where x and y are standard - containers, then the call will automatically be replaced by a call to - x.swap(y); instead. -

    This allows member functions of each container class to take over, and - containers' swap functions should have O(1) complexity according to - the standard. (And while "should" allows implementations to - behave otherwise and remain compliant, this implementation does in - fact use constant-time swaps.) This should not be surprising, since - for two containers of the same type to swap contents, only some - internal pointers to storage need to be exchanged. -

    Prev Up Next
     Home Part X.  - Numerics - -
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt09pr02.html b/libstdc++-v3/doc/html/manual/bk01pt09pr02.html deleted file mode 100644 index c81bbee976e..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt09pr02.html +++ /dev/null @@ -1,41 +0,0 @@ - - -
    Prev Part IX.  - Algorithms - - Next

    - The neatest accomplishment of the algorithms chapter is that all the - work is done via iterators, not containers directly. This means two - important things: -

    1. - Anything that behaves like an iterator can be used in one of - these algorithms. Raw pointers make great candidates, thus - built-in arrays are fine containers, as well as your own iterators. -

    2. - The algorithms do not (and cannot) affect the container as a - whole; only the things between the two iterator endpoints. If - you pass a range of iterators only enclosing the middle third of - a container, then anything outside that range is inviolate. -

    - Even strings can be fed through the algorithms here, although the - string class has specialized versions of many of these functions - (for example, string::find()). Most of the examples - on this page will use simple arrays of integers as a playground - for algorithms, just to keep things simple. The use of - N as a size in the examples is to keep - things easy to read but probably won't be valid code. You can - use wrappers such as those described in the containers chapter to - keep real code readable. -

    - The single thing that trips people up the most is the definition - of range used with iterators; the famous - "past-the-end" rule that everybody loves to hate. The - iterators - chapter of this document has a complete explanation of - this simple rule that seems to cause so much confusion. Once you - get range into your head (it's not that - hard, honest!), then the algorithms are a cakewalk. -

    Prev Up Next
    Part IX.  - Algorithms - - Home Chapter 20. Mutating
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt10ch23s02.html b/libstdc++-v3/doc/html/manual/bk01pt10ch23s02.html deleted file mode 100644 index 31c37c741cf..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt10ch23s02.html +++ /dev/null @@ -1,19 +0,0 @@ - - -C99
    C99
    Prev Chapter 23. Interacting with C Next

    C99

    In addition to the other topics on this page, we'll note here some - of the C99 features that appear in libstdc++. -

    The C99 features depend on the --enable-c99 configure flag. - This flag is already on by default, but it can be disabled by the - user. Also, the configuration machinery will disable it if the - necessary support for C99 (e.g., header files) cannot be found. -

    As of GCC 3.0, C99 support includes classification functions - such as isnormal, isgreater, - isnan, etc. - The functions used for 'long long' support such as strtoll - are supported, as is the lldiv_t typedef. Also supported - are the wide character functions using 'long long', like - wcstoll. -

    Prev Up Next
    Chapter 23. Interacting with C Home Part XI.  - Input and Output - -
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt12ch30s03.html b/libstdc++-v3/doc/html/manual/bk01pt12ch30s03.html deleted file mode 100644 index 2d56fc66378..00000000000 --- a/libstdc++-v3/doc/html/manual/bk01pt12ch30s03.html +++ /dev/null @@ -1,24 +0,0 @@ - - -Using
    Using
    Prev Chapter 30. Debug Mode Next

    Using

    -

    Using the Debug Mode

    To use the libstdc++ debug mode, compile your application with the - compiler flag -D_GLIBCXX_DEBUG. Note that this flag - changes the sizes and behavior of standard class templates such - as std::vector, and therefore you can only link code - compiled with debug mode and code compiled without debug mode if no - instantiation of a container is passed between the two translation - units.

    By default, error messages are formatted to fit on lines of about - 78 characters. The environment variable - GLIBCXX_DEBUG_MESSAGE_LENGTH can be used to request a - different length.

    Using a Specific Debug Container

    When it is not feasible to recompile your entire application, or - only specific containers need checking, debugging containers are - available as GNU extensions. These debugging containers are - functionally equivalent to the standard drop-in containers used in - debug mode, but they are available in a separate namespace as GNU - extensions and may be used in programs compiled with either release - mode or with debug mode. The - following table provides the names and headers of the debugging - containers: -

    Table 30.1. Debugging Containers

    ContainerHeaderDebug containerDebug header
    std::bitsetbitset__gnu_debug::bitsetbitset
    std::dequedeque__gnu_debug::dequedeque
    std::listlist__gnu_debug::listlist
    std::mapmap__gnu_debug::mapmap
    std::multimapmap__gnu_debug::multimapmap
    std::multisetset__gnu_debug::multisetset
    std::setset__gnu_debug::setset
    std::stringstring__gnu_debug::stringstring
    std::wstringstring__gnu_debug::wstringstring
    std::basic_stringstring__gnu_debug::basic_stringstring
    std::vectorvector__gnu_debug::vectorvector

    In addition, when compiling in C++0x mode, these additional -containers have additional debug capability. -

    Table 30.2. Debugging Containers C++0x

    ContainerHeaderDebug containerDebug header
    std::unordered_mapunordered_map__gnu_debug::unordered_mapunordered_map
    std::unordered_multimapunordered_map__gnu_debug::unordered_multimapunordered_map
    std::unordered_setunordered_set__gnu_debug::unordered_setunordered_set
    std::unordered_multisetunordered_set__gnu_debug::unordered_multisetunordered_set

    Prev Up Next
    Semantics Home Design
    diff --git a/libstdc++-v3/doc/html/manual/bugs.html b/libstdc++-v3/doc/html/manual/bugs.html index 20da4a8fbf4..88ec80cabb2 100644 --- a/libstdc++-v3/doc/html/manual/bugs.html +++ b/libstdc++-v3/doc/html/manual/bugs.html @@ -36,317 +36,317 @@ of style. Note that we usually do not make changes to the code until an issue has reached DR status.

    5: - string::compare specification questionable + string::compare specification questionable

    This should be two overloaded functions rather than a single function.

    17: - Bad bool parsing + Bad bool parsing

    Apparently extracting Boolean values was messed up...

    19: - "Noconv" definition too vague + "Noconv" definition too vague

    If codecvt::do_in returns noconv there are - no changes to the values in [to, to_limit). + no changes to the values in [to, to_limit).

    22: - Member open vs flags + Member open vs flags

    Re-opening a file stream does not clear the state flags.

    23: - Num_get overflow result + Num_get overflow result

    Implement the proposed resolution.

    25: - String operator<< uses width() value wrong + String operator<< uses width() value wrong

    Padding issues.

    48: - Use of non-existent exception constructor + Use of non-existent exception constructor

    An instance of ios_base::failure is constructed instead.

    49: - Underspecification of ios_base::sync_with_stdio + Underspecification of ios_base::sync_with_stdio

    The return type is the previous state of synchronization.

    50: - Copy constructor and assignment operator of ios_base + Copy constructor and assignment operator of ios_base

    These members functions are declared private and are - thus inaccessible. Specifying the correct semantics of - "copying stream state" was deemed too complicated. + thus inaccessible. Specifying the correct semantics of + "copying stream state" was deemed too complicated.

    60: - What is a formatted input function? + What is a formatted input function?

    This DR made many widespread changes to basic_istream - and basic_ostream all of which have been implemented. + and basic_ostream all of which have been implemented.

    63: - Exception-handling policy for unformatted output + Exception-handling policy for unformatted output

    Make the policy consistent with that of formatted input, unformatted - input, and formatted output. + input, and formatted output.

    68: - Extractors for char* should store null at end + Extractors for char* should store null at end

    And they do now. An editing glitch in the last item in the list of - [27.6.1.2.3]/7. + [27.6.1.2.3]/7.

    74: - Garbled text for codecvt::do_max_length + Garbled text for codecvt::do_max_length

    The text of the standard was gibberish. Typos gone rampant.

    75: - Contradiction in codecvt::length's argument types + Contradiction in codecvt::length's argument types

    Change the first parameter to stateT& and implement - the new effects paragraph. + the new effects paragraph.

    83: - string::npos vs. string::max_size() + string::npos vs. string::max_size()

    Safety checks on the size of the string should test against - max_size() rather than npos. + max_size() rather than npos.

    90: - Incorrect description of operator>> for strings + Incorrect description of operator>> for strings

    The effect contain isspace(c,getloc()) which must be - replaced by isspace(c,is.getloc()). + replaced by isspace(c,is.getloc()).

    91: - Description of operator>> and getline() for string<> + Description of operator>> and getline() for string<> might cause endless loop

    They behave as a formatted input function and as an unformatted - input function, respectively (except that getline is + input function, respectively (except that getline is not required to set gcount).

    103: - set::iterator is required to be modifiable, but this allows + set::iterator is required to be modifiable, but this allows modification of keys.

    For associative containers where the value type is the same as - the key type, both iterator and const_iterator + the key type, both iterator and const_iterator are constant iterators.

    109: - Missing binders for non-const sequence elements + Missing binders for non-const sequence elements

    The binder1st and binder2nd didn't have an - operator() taking a non-const parameter. + operator() taking a non-const parameter.

    110: - istreambuf_iterator::equal not const + istreambuf_iterator::equal not const

    This was not a const member function. Note that the DR says to - replace the function with a const one; we have instead provided an - overloaded version with identical contents. + replace the function with a const one; we have instead provided an + overloaded version with identical contents.

    117: - basic_ostream uses nonexistent num_put member functions + basic_ostream uses nonexistent num_put member functions

    num_put::put() was overloaded on the wrong types.

    118: - basic_istream uses nonexistent num_get member functions + basic_istream uses nonexistent num_get member functions

    Same as 117, but for num_get::get().

    129: - Need error indication from seekp() and seekg() + Need error indication from seekp() and seekg()

    These functions set failbit on error now.

    130: - Return type of container::erase(iterator) differs for associative containers -

    Make member erase return iterator for set, multiset, map, multimap. + Return type of container::erase(iterator) differs for associative containers +

    Make member erase return iterator for set, multiset, map, multimap.

    136: - seekp, seekg setting wrong streams? + seekp, seekg setting wrong streams?

    seekp should only set the output stream, and - seekg should only set the input stream. + seekg should only set the input stream.

    167: - Improper use of traits_type::length() + Improper use of traits_type::length()

    op<< with a const char* was - calculating an incorrect number of characters to write. + calculating an incorrect number of characters to write.

    169: - Bad efficiency of overflow() mandated + Bad efficiency of overflow() mandated

    Grow efficiently the internal array object.

    171: - Strange seekpos() semantics due to joint position + Strange seekpos() semantics due to joint position

    Quite complex to summarize...

    181: - make_pair() unintended behavior + make_pair() unintended behavior

    This function used to take its arguments as reference-to-const, now - it copies them (pass by value). + it copies them (pass by value).

    195: - Should basic_istream::sentry's constructor ever set eofbit? + Should basic_istream::sentry's constructor ever set eofbit?

    Yes, it can, specifically if EOF is reached while skipping whitespace.

    211: - operator>>(istream&, string&) doesn't set failbit + operator>>(istream&, string&) doesn't set failbit

    If nothing is extracted into the string, op>> now - sets failbit (which can cause an exception, etc., etc.). + sets failbit (which can cause an exception, etc., etc.).

    214: - set::find() missing const overload + set::find() missing const overload

    Both set and multiset were missing - overloaded find, lower_bound, upper_bound, and equal_range functions - for const instances. + overloaded find, lower_bound, upper_bound, and equal_range functions + for const instances.

    231: - Precision in iostream? + Precision in iostream?

    For conversion from a floating-point type, str.precision() - is specified in the conversion specification. + is specified in the conversion specification.

    233: - Insertion hints in associative containers + Insertion hints in associative containers

    Implement N1780, first check before then check after, insert as close - to hint as possible. + to hint as possible.

    235: - No specification of default ctor for reverse_iterator + No specification of default ctor for reverse_iterator

    The declaration of reverse_iterator lists a default constructor. - However, no specification is given what this constructor should do. + However, no specification is given what this constructor should do.

    241: - Does unique_copy() require CopyConstructible and Assignable? + Does unique_copy() require CopyConstructible and Assignable?

    Add a helper for forward_iterator/output_iterator, fix the existing - one for input_iterator/output_iterator to not rely on Assignability. + one for input_iterator/output_iterator to not rely on Assignability.

    243: - get and getline when sentry reports failure + get and getline when sentry reports failure

    Store a null character only if the character array has a non-zero size.

    251: - basic_stringbuf missing allocator_type + basic_stringbuf missing allocator_type

    This nested typedef was originally not specified.

    253: - valarray helper functions are almost entirely useless + valarray helper functions are almost entirely useless

    Make the copy constructor and copy-assignment operator declarations - public in gslice_array, indirect_array, mask_array, slice_array; provide + public in gslice_array, indirect_array, mask_array, slice_array; provide definitions.

    265: - std::pair::pair() effects overly restrictive + std::pair::pair() effects overly restrictive

    The default ctor would build its members from copies of temporaries; - now it simply uses their respective default ctors. + now it simply uses their respective default ctors.

    266: - bad_exception::~bad_exception() missing Effects clause + bad_exception::~bad_exception() missing Effects clause

    The bad_* classes no longer have destructors (they - are trivial), since no description of them was ever given. + are trivial), since no description of them was ever given.

    271: - basic_iostream missing typedefs + basic_iostream missing typedefs

    The typedefs it inherits from its base classes can't be used, since - (for example) basic_iostream<T>::traits_type is ambiguous. + (for example) basic_iostream<T>::traits_type is ambiguous.

    275: - Wrong type in num_get::get() overloads + Wrong type in num_get::get() overloads

    Similar to 118.

    280: - Comparison of reverse_iterator to const reverse_iterator + Comparison of reverse_iterator to const reverse_iterator

    Add global functions with two template parameters. - (NB: not added for now a templated assignment operator) + (NB: not added for now a templated assignment operator)

    292: - Effects of a.copyfmt (a) + Effects of a.copyfmt (a)

    If (this == &rhs) do nothing.

    300: - List::merge() specification incomplete + List::merge() specification incomplete

    If (this == &x) do nothing.

    303: - Bitset input operator underspecified -

    Basically, compare the input character to - is.widen(0) and is.widen(1). + Bitset input operator underspecified +

    Basically, compare the input character to + is.widen(0) and is.widen(1).

    305: - Default behavior of codecvt<wchar_t, char, - mbstate_t>::length() -

    Do not specify what codecvt<wchar_t, char, - mbstate_t>::do_length must return. + Default behavior of codecvt<wchar_t, char, + mbstate_t>::length() +

    Do not specify what codecvt<wchar_t, char, + mbstate_t>::do_length must return.

    328: - Bad sprintf format modifier in - money_put<>::do_put() + Bad sprintf format modifier in + money_put<>::do_put()

    Change the format string to "%.0Lf".

    365: - Lack of const-qualification in clause 27 + Lack of const-qualification in clause 27

    Add const overloads of is_open.

    387: - std::complex over-encapsulated + std::complex over-encapsulated

    Add the real(T) and imag(T) - members; in C++0x mode, also adjust the existing - real() and imag() members and - free functions. + members; in C++0x mode, also adjust the existing + real() and imag() members and + free functions.

    389: - Const overload of valarray::operator[] returns - by value + Const overload of valarray::operator[] returns + by value

    Change it to return a const T&.

    396: - what are characters zero and one + what are characters zero and one

    Implement the proposed resolution.

    402: - Wrong new expression in [some_]allocator::construct + Wrong new expression in [some_]allocator::construct

    Replace "new" with "::new".

    408: - - Is vector<reverse_iterator<char*> > forbidden? - + + Is vector<reverse_iterator<char*> > forbidden? +

    Tweak the debug-mode checks in _Safe_iterator.

    409: - Closing an fstream should clear the error state + Closing an fstream should clear the error state

    Have open clear the error flags.

    431: - Swapping containers with unequal allocators + Swapping containers with unequal allocators

    Implement Option 3, as per N1599.

    432: - stringbuf::overflow() makes only one write position + stringbuf::overflow() makes only one write position available

    Implement the resolution, beyond DR 169.

    434: - bitset::to_string() hard to use + bitset::to_string() hard to use

    Add three overloads, taking fewer template arguments.

    438: - Ambiguity in the "do the right thing" clause + Ambiguity in the "do the right thing" clause

    Implement the resolution, basically cast less.

    453: - basic_stringbuf::seekoff need not always fail for an empty stream + basic_stringbuf::seekoff need not always fail for an empty stream

    Don't fail if the next pointer is null and newoff is zero.

    455: - cerr::tie() and wcerr::tie() are overspecified + cerr::tie() and wcerr::tie() are overspecified

    Initialize cerr tied to cout and wcerr tied to wcout.

    464: - Suggestion for new member functions in standard containers + Suggestion for new member functions in standard containers

    Add data() to std::vector and - at(const key_type&) to std::map. + at(const key_type&) to std::map.

    508: - Bad parameters for ranlux64_base_01 + Bad parameters for ranlux64_base_01

    Fix the parameters.

    512: - Seeding subtract_with_carry_01 from a single unsigned long + Seeding subtract_with_carry_01 from a single unsigned long

    Construct a linear_congruential engine and seed with it.

    526: - Is it undefined if a function in the standard changes in + Is it undefined if a function in the standard changes in parameters?

    Use &value.

    538: - 241 again: Does unique_copy() require CopyConstructible + 241 again: Does unique_copy() require CopyConstructible and Assignable?

    In case of input_iterator/output_iterator rely on Assignability of - input_iterator' value_type. + input_iterator' value_type.

    539: - partial_sum and adjacent_difference should mention - requirements + partial_sum and adjacent_difference should mention + requirements

    We were almost doing the right thing, just use std::move - in adjacent_difference. + in adjacent_difference.

    541: - shared_ptr template assignment and void + shared_ptr template assignment and void

    Add an auto_ptr<void> specialization.

    543: - valarray slice default constructor + valarray slice default constructor

    Follow the straightforward proposed resolution.

    550: - What should the return type of pow(float,int) be? + What should the return type of pow(float,int) be?

    In C++0x mode, remove the pow(float,int), etc., signatures.

    586: - string inserter not a formatted function + string inserter not a formatted function

    Change it to be a formatted output function (i.e. catch exceptions).

    596: - 27.8.1.3 Table 112 omits "a+" and "a+b" modes + 27.8.1.3 Table 112 omits "a+" and "a+b" modes

    Add the missing modes to fopen_mode.

    630: - arrays of valarray + arrays of valarray

    Implement the simple resolution.

    660: - Missing bitwise operations + Missing bitwise operations

    Add the missing operations.

    691: - const_local_iterator cbegin, cend missing from TR1 + const_local_iterator cbegin, cend missing from TR1

    In C++0x mode add cbegin(size_type) and cend(size_type) - to the unordered containers. + to the unordered containers.

    693: - std::bitset::all() missing + std::bitset::all() missing

    Add it, consistently with the discussion.

    695: - ctype<char>::classic_table() not accessible + ctype<char>::classic_table() not accessible

    Make the member functions table and classic_table public.

    696: - istream::operator>>(int&) broken + istream::operator>>(int&) broken

    Implement the straightforward resolution.

    761: - unordered_map needs an at() member function + unordered_map needs an at() member function

    In C++0x mode, add at() and at() const.

    775: - Tuple indexing should be unsigned? + Tuple indexing should be unsigned?

    Implement the int -> size_t replacements.

    776: - Undescribed assign function of std::array + Undescribed assign function of std::array

    In C++0x mode, remove assign, add fill.

    781: - std::complex should add missing C99 functions + std::complex should add missing C99 functions

    In C++0x mode, add std::proj.

    809: - std::swap should be overloaded for array types + std::swap should be overloaded for array types

    Add the overload.

    844: - complex pow return type is ambiguous + complex pow return type is ambiguous

    In C++0x mode, remove the pow(complex<T>, int) signature.

    853: - to_string needs updating with zero and one + to_string needs updating with zero and one

    Update / add the signatures.

    865: - More algorithms that throw away information + More algorithms that throw away information

    The traditional HP / SGI return type and value is blessed - by the resolution of the DR. + by the resolution of the DR.

    Prev Up Next
    License Home Chapter 2. Setup
    diff --git a/libstdc++-v3/doc/html/manual/codecvt.html b/libstdc++-v3/doc/html/manual/codecvt.html deleted file mode 100644 index 1e45a2582cb..00000000000 --- a/libstdc++-v3/doc/html/manual/codecvt.html +++ /dev/null @@ -1,379 +0,0 @@ - - -codecvt
    codecvt
    Prev Chapter 15. Facets aka Categories Next

    codecvt

    -The standard class codecvt attempts to address conversions between -different character encoding schemes. In particular, the standard -attempts to detail conversions between the implementation-defined wide -characters (hereafter referred to as wchar_t) and the standard type -char that is so beloved in classic “C” (which can now be -referred to as narrow characters.) This document attempts to describe -how the GNU libstdc++ implementation deals with the conversion between -wide and narrow characters, and also presents a framework for dealing -with the huge number of other encodings that iconv can convert, -including Unicode and UTF8. Design issues and requirements are -addressed, and examples of correct usage for both the required -specializations for wide and narrow characters and the -implementation-provided extended functionality are given. -

    Requirements

    -Around page 425 of the C++ Standard, this charming heading comes into view: -

    -22.2.1.5 - Template class codecvt -

    -The text around the codecvt definition gives some clues: -

    - --1- The class codecvt<internT,externT,stateT> is for use when -converting from one codeset to another, such as from wide characters -to multibyte characters, between wide character encodings such as -Unicode and EUC. - -

    -Hmm. So, in some unspecified way, Unicode encodings and -translations between other character sets should be handled by this -class. -

    - --2- The stateT argument selects the pair of codesets being mapped between. - -

    -Ah ha! Another clue... -

    - --3- The instantiations required in the Table ?? -(lib.locale.category), namely codecvt<wchar_t,char,mbstate_t> and -codecvt<char,char,mbstate_t>, convert the implementation-defined -native character set. codecvt<char,char,mbstate_t> implements a -degenerate conversion; it does not convert at -all. codecvt<wchar_t,char,mbstate_t> converts between the native -character sets for tiny and wide characters. Instantiations on -mbstate_t perform conversion between encodings known to the library -implementor. Other encodings can be converted by specializing on a -user-defined stateT type. The stateT object can contain any state that -is useful to communicate to or from the specialized do_convert member. - -

    -At this point, a couple points become clear: -

    -One: The standard clearly implies that attempts to add non-required -(yet useful and widely used) conversions need to do so through the -third template parameter, stateT.

    -Two: The required conversions, by specifying mbstate_t as the third -template parameter, imply an implementation strategy that is mostly -(or wholly) based on the underlying C library, and the functions -mcsrtombs and wcsrtombs in particular.

    Design

    wchar_t Size

    - The simple implementation detail of wchar_t's size seems to - repeatedly confound people. Many systems use a two byte, - unsigned integral type to represent wide characters, and use an - internal encoding of Unicode or UCS2. (See AIX, Microsoft NT, - Java, others.) Other systems, use a four byte, unsigned integral - type to represent wide characters, and use an internal encoding - of UCS4. (GNU/Linux systems using glibc, in particular.) The C - programming language (and thus C++) does not specify a specific - size for the type wchar_t. -

    - Thus, portable C++ code cannot assume a byte size (or endianness) either. -

    Support for Unicode

    - Probably the most frequently asked question about code conversion - is: "So dudes, what's the deal with Unicode strings?" - The dude part is optional, but apparently the usefulness of - Unicode strings is pretty widely appreciated. Sadly, this specific - encoding (And other useful encodings like UTF8, UCS4, ISO 8859-10, - etc etc etc) are not mentioned in the C++ standard. -

    - A couple of comments: -

    - The thought that all one needs to convert between two arbitrary - codesets is two types and some kind of state argument is - unfortunate. In particular, encodings may be stateless. The naming - of the third parameter as stateT is unfortunate, as what is really - needed is some kind of generalized type that accounts for the - issues that abstract encodings will need. The minimum information - that is required includes: -

    • - Identifiers for each of the codesets involved in the - conversion. For example, using the iconv family of functions - from the Single Unix Specification (what used to be called - X/Open) hosted on the GNU/Linux operating system allows - bi-directional mapping between far more than the following - tantalizing possibilities: -

      - (An edited list taken from `iconv --list` on a - Red Hat 6.2/Intel system: - 

      -8859_1, 8859_9, 10646-1:1993, 10646-1:1993/UCS4, ARABIC, ARABIC7,
-ASCII, EUC-CN, EUC-JP, EUC-KR, EUC-TW, GREEK-CCIcode, GREEK, GREEK7-OLD,
-GREEK7, GREEK8, HEBREW, ISO-8859-1, ISO-8859-2, ISO-8859-3,
-ISO-8859-4, ISO-8859-5, ISO-8859-6, ISO-8859-7, ISO-8859-8,
-ISO-8859-9, ISO-8859-10, ISO-8859-11, ISO-8859-13, ISO-8859-14,
-ISO-8859-15, ISO-10646, ISO-10646/UCS2, ISO-10646/UCS4,
-ISO-10646/UTF-8, ISO-10646/UTF8, SHIFT-JIS, SHIFT_JIS, UCS-2, UCS-4,
-UCS2, UCS4, UNICODE, UNICODEBIG, UNICODELIcodeLE, US-ASCII, US, UTF-8,
-UTF-16, UTF8, UTF16).
-

      -For iconv-based implementations, string literals for each of the -encodings (i.e. "UCS-2" and "UTF-8") are necessary, -although for other, -non-iconv implementations a table of enumerated values or some other -mechanism may be required. -

    • - Maximum length of the identifying string literal. -

    • - Some encodings require explicit endian-ness. As such, some kind - of endian marker or other byte-order marker will be necessary. See - "Footnotes for C/C++ developers" in Haible for more information on - UCS-2/Unicode endian issues. (Summary: big endian seems most likely, - however implementations, most notably Microsoft, vary.) -

    • - Types representing the conversion state, for conversions involving - the machinery in the "C" library, or the conversion descriptor, for - conversions using iconv (such as the type iconv_t.) Note that the - conversion descriptor encodes more information than a simple encoding - state type. -

    • - Conversion descriptors for both directions of encoding. (i.e., both - UCS-2 to UTF-8 and UTF-8 to UCS-2.) -

    • - Something to indicate if the conversion requested if valid. -

    • - Something to represent if the conversion descriptors are valid. -

    • - Some way to enforce strict type checking on the internal and - external types. As part of this, the size of the internal and - external types will need to be known. -

    Other Issues

    -In addition, multi-threaded and multi-locale environments also impact -the design and requirements for code conversions. In particular, they -affect the required specialization codecvt<wchar_t, char, mbstate_t> -when implemented using standard "C" functions. -

    -Three problems arise, one big, one of medium importance, and one small. -

    -First, the small: mcsrtombs and wcsrtombs may not be multithread-safe -on all systems required by the GNU tools. For GNU/Linux and glibc, -this is not an issue. -

    -Of medium concern, in the grand scope of things, is that the functions -used to implement this specialization work on null-terminated -strings. Buffers, especially file buffers, may not be null-terminated, -thus giving conversions that end prematurely or are otherwise -incorrect. Yikes! -

    -The last, and fundamental problem, is the assumption of a global -locale for all the "C" functions referenced above. For something like -C++ iostreams (where codecvt is explicitly used) the notion of -multiple locales is fundamental. In practice, most users may not run -into this limitation. However, as a quality of implementation issue, -the GNU C++ library would like to offer a solution that allows -multiple locales and or simultaneous usage with computationally -correct results. In short, libstdc++ is trying to offer, as an -option, a high-quality implementation, damn the additional complexity! -

    -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 -LC_CTYPE category implements. -

    Implementation

    -The two required specializations are implemented as follows: -

    - -codecvt<char, char, mbstate_t> - -

    -This is a degenerate (i.e., does nothing) specialization. Implementing -this was a piece of cake. -

    - -codecvt<char, wchar_t, mbstate_t> - -

    -This specialization, by specifying all the template parameters, pretty -much ties the hands of implementors. As such, the implementation is -straightforward, involving mcsrtombs for the conversions between char -to wchar_t and wcsrtombs for conversions between wchar_t and char. -

    -Neither of these two required specializations deals with Unicode -characters. As such, libstdc++ implements a partial specialization -of the codecvt class with and iconv wrapper class, encoding_state as the -third template parameter. -

    -This implementation should be standards conformant. First of all, the -standard explicitly points out that instantiations on the third -template parameter, stateT, are the proper way to implement -non-required conversions. Second of all, the standard says (in Chapter -17) that partial specializations of required classes are a-ok. Third -of all, the requirements for the stateT type elsewhere in the standard -(see 21.1.2 traits typedefs) only indicate that this type be copy -constructible. -

    -As such, the type encoding_state is defined as a non-templatized, POD -type to be used as the third type of a codecvt instantiation. This -type is just a wrapper class for iconv, and provides an easy interface -to iconv functionality. -

    -There are two constructors for encoding_state: -

    - -encoding_state() : __in_desc(0), __out_desc(0) - -

    -This default constructor sets the internal encoding to some default -(currently UCS4) and the external encoding to whatever is returned by -nl_langinfo(CODESET). -

    - -encoding_state(const char* __int, const char* __ext) - -

    -This constructor takes as parameters string literals that indicate the -desired internal and external encoding. There are no defaults for -either argument. -

    -One of the issues with iconv is that the string literals identifying -conversions are not standardized. Because of this, the thought of -mandating and or enforcing some set of pre-determined valid -identifiers seems iffy: thus, a more practical (and non-migraine -inducing) strategy was implemented: end-users can specify any string -(subject to a pre-determined length qualifier, currently 32 bytes) for -encodings. It is up to the user to make sure that these strings are -valid on the target system. -

    - -void -_M_init() - -

    -Strangely enough, this member function attempts to open conversion -descriptors for a given encoding_state object. If the conversion -descriptors are not valid, the conversion descriptors returned will -not be valid and the resulting calls to the codecvt conversion -functions will return error. -

    - -bool -_M_good() - -

    -Provides a way to see if the given encoding_state object has been -properly initialized. If the string literals describing the desired -internal and external encoding are not valid, initialization will -fail, and this will return false. If the internal and external -encodings are valid, but iconv_open could not allocate conversion -descriptors, this will also return false. Otherwise, the object is -ready to convert and will return true. -

    - -encoding_state(const encoding_state&) - -

    -As iconv allocates memory and sets up conversion descriptors, the copy -constructor can only copy the member data pertaining to the internal -and external code conversions, and not the conversion descriptors -themselves. -

    -Definitions for all the required codecvt member functions are provided -for this specialization, and usage of codecvt<internal character type, -external character type, encoding_state> is consistent with other -codecvt usage. -

    Use

    A conversions involving string literal.

    -  typedef codecvt_base::result                  result;
-  typedef unsigned short                        unicode_t;
-  typedef unicode_t                             int_type;
-  typedef char                                  ext_type;
-  typedef encoding_state                          state_type;
-  typedef codecvt<int_type, ext_type, state_type> unicode_codecvt;
-
-  const ext_type*       e_lit = "black pearl jasmine tea";
-  int                   size = strlen(e_lit);
-  int_type              i_lit_base[24] = 
-  { 25088, 27648, 24832, 25344, 27392, 8192, 28672, 25856, 24832, 29184, 
-    27648, 8192, 27136, 24832, 29440, 27904, 26880, 28160, 25856, 8192, 29696,
-    25856, 24832, 2560
-  };
-  const int_type*       i_lit = i_lit_base;
-  const ext_type*       efrom_next;
-  const int_type*       ifrom_next;
-  ext_type*             e_arr = new ext_type[size + 1];
-  ext_type*             eto_next;
-  int_type*             i_arr = new int_type[size + 1];
-  int_type*             ito_next;
-
-  // construct a locale object with the specialized facet.
-  locale                loc(locale::classic(), new unicode_codecvt);
-  // sanity check the constructed locale has the specialized facet.
-  VERIFY( has_facet<unicode_codecvt>(loc) );
-  const unicode_codecvt& cvt = use_facet<unicode_codecvt>(loc); 
-  // convert between const char* and unicode strings
-  unicode_codecvt::state_type state01("UNICODE", "ISO_8859-1");
-  initialize_state(state01);
-  result r1 = cvt.in(state01, e_lit, e_lit + size, efrom_next, 
-                     i_arr, i_arr + size, ito_next);
-  VERIFY( r1 == codecvt_base::ok );
-  VERIFY( !int_traits::compare(i_arr, i_lit, size) ); 
-  VERIFY( efrom_next == e_lit + size );
-  VERIFY( ito_next == i_arr + size );
-

    Future

    • - a. things that are sketchy, or remain unimplemented: - do_encoding, max_length and length member functions - are only weakly implemented. I have no idea how to do - this correctly, and in a generic manner. Nathan? -

    • - b. conversions involving std::string -

      • - how should operators != and == work for string of - different/same encoding? -

      • - what is equal? A byte by byte comparison or an - encoding then byte comparison? -

      • - conversions between narrow, wide, and unicode strings -

    • - c. conversions involving std::filebuf and std::ostream -

      • - how to initialize the state object in a - standards-conformant manner? -

      • - how to synchronize the "C" and "C++" - conversion information? -

      • - wchar_t/char internal buffers and conversions between - internal/external buffers? -

    Bibliography

    - The GNU C Library - . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization.

    - Correspondence - . Ulrich Drepper. Copyright © 2002 .

    - ISO/IEC 14882:1998 Programming languages - C++ - . Copyright © 1998 ISO.

    - ISO/IEC 9899:1999 Programming languages - C - . Copyright © 1999 ISO.

    - The Open Group Base Specifications, Issue 6 (IEEE Std. 1003.1-2004) - . Copyright © 1999 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. - - - .

    - The C++ Programming Language, Special Edition - . Bjarne Stroustrup. Copyright © 2000 Addison Wesley, Inc.. Appendix D. - Addison Wesley - .

    - Standard C++ IOStreams and Locales - . - Advanced Programmer's Guide and Reference - . Angelika Langer. Klaus Kreft. Copyright © 2000 Addison Wesley Longman, Inc.. - Addison Wesley Longman - .

    - A brief description of Normative Addendum 1 - . Clive Feather. Extended Character Sets. - - - .

    - The Unicode HOWTO - . Bruno Haible. - - - .

    - UTF-8 and Unicode FAQ for Unix/Linux - . Markus Khun. - - - .

    Prev Up Next
    Chapter 15. Facets aka Categories Home messages
    diff --git a/libstdc++-v3/doc/html/manual/complex.html b/libstdc++-v3/doc/html/manual/complex.html deleted file mode 100644 index cb82e609eab..00000000000 --- a/libstdc++-v3/doc/html/manual/complex.html +++ /dev/null @@ -1,25 +0,0 @@ - - -Chapter 21. Complex
    Chapter 21. Complex
    Prev Part X.  - Numerics - - Next

    Chapter 21. Complex

    Table of Contents

    complex Processing

    -

    complex Processing

    -

    Using complex<> becomes even more comple- er, sorry, - complicated, with the not-quite-gratuitously-incompatible - addition of complex types to the C language. David Tribble has - compiled a list of C++98 and C99 conflict points; his description of - C's new type versus those of C++ and how to get them playing together - nicely is -here. -

    complex<> is intended to be instantiated with a - floating-point type. As long as you meet that and some other basic - requirements, then the resulting instantiation has all of the usual - math operators defined, as well as definitions of op<< - and op>> that work with iostreams: op<< - prints (u,v) and op>> can read u, - (u), and (u,v). -

    Prev Up Next
    Part X.  - Numerics - - Home Chapter 22. Generalized Operations
    diff --git a/libstdc++-v3/doc/html/manual/concurrency.html b/libstdc++-v3/doc/html/manual/concurrency.html new file mode 100644 index 00000000000..86de72e9c04 --- /dev/null +++ b/libstdc++-v3/doc/html/manual/concurrency.html @@ -0,0 +1,42 @@ + + +Chapter 15.  Concurrency
    Chapter 15.  + Concurrency + +
    Prev Part II.  + Standard Contents + Next

    Chapter 15.  + Concurrency + +

    Table of Contents

    API Reference

    + Facilities for concurrent operation, and control thereof. +

    API Reference

    + All items are declared in one of four standard header files. +

    + In header mutex, class + template mutex and variants, + class once_flag, and class + template unique_lock. +

    + In header condition_variable, + classes condition_variable + and condition_variable_any. +

    + In header thread, + class thread and + namespace this_thread. +

    + In header future, class + template future and class + template shared_future, class + template promise, + and packaged_task. +

    + Full API details. +

    Prev Up Next
    Chapter 14.  + Atomics + + Home Part III.  + Extensions + +
    diff --git a/libstdc++-v3/doc/html/manual/configure.html b/libstdc++-v3/doc/html/manual/configure.html index c5ee8c3b546..47f58f47f89 100644 --- a/libstdc++-v3/doc/html/manual/configure.html +++ b/libstdc++-v3/doc/html/manual/configure.html @@ -19,43 +19,43 @@ available for a given set of libstdc++ sources is to go to the source directory and then type:./configure --help.

    --enable-multilib[default]

    This is part of the generic multilib support for building cross - compilers. As such, targets like "powerpc-elf" will have - libstdc++ built many different ways: "-msoft-float" - and not, etc. A different libstdc++ will be built for each of - the different multilib versions. This option is on by default. + compilers. As such, targets like "powerpc-elf" will have + libstdc++ built many different ways: "-msoft-float" + and not, etc. A different libstdc++ will be built for each of + the different multilib versions. This option is on by default.

    --enable-sjlj-exceptions

    Forces old, set-jump/long-jump exception handling model. If - at all possible, the new, frame unwinding exception handling routines - should be used instead, as they significantly reduce both - runtime memory usage and executable size. This option can - change the library ABI. + at all possible, the new, frame unwinding exception handling routines + should be used instead, as they significantly reduce both + runtime memory usage and executable size. This option can + change the library ABI.

    --enable-version-specific-runtime-libs

    Specify that run-time libraries should be installed in the - compiler-specific subdirectory (i.e., - ${libdir}/gcc-lib/${target_alias}/${gcc_version}) - instead of ${libdir}. This option is useful if you - intend to use several versions of gcc in parallel. In addition, - libstdc++'s include files will be installed in - ${libdir}/gcc-lib/${target_alias}/${gcc_version}/include/g++, - unless you also specify + compiler-specific subdirectory (i.e., + ${libdir}/gcc-lib/${target_alias}/${gcc_version}) + instead of ${libdir}. This option is useful if you + intend to use several versions of gcc in parallel. In addition, + libstdc++'s include files will be installed in + ${libdir}/gcc-lib/${target_alias}/${gcc_version}/include/g++, + unless you also specify --with-gxx-include-dir=dirname during configuration.

    --with-gxx-include-dir=<include-files dir>

    Adds support for named libstdc++ include directory. For instance, - the following puts all the libstdc++ headers into a directory - called "4.4-20090404" instead of the usual - "c++/(version)". + the following puts all the libstdc++ headers into a directory + called "4.4-20090404" instead of the usual + "c++/(version)". 

        --with-gxx-include-dir=/foo/H-x86-gcc-3-c-gxx-inc/include/4.4-20090404
    --enable-cstdio

    This is an abbreviated form of '--enable-cstdio=stdio' - (described next). + (described next).

    --enable-cstdio=OPTION

    Select a target-specific I/O package. At the moment, the only - choice is to use 'stdio', a generic "C" abstraction. - The default is 'stdio'. This option can change the library ABI. + choice is to use 'stdio', a generic "C" abstraction. + The default is 'stdio'. This option can change the library ABI.

    --enable-clocale

    This is an abbreviated form of '--enable-clocale=generic' - (described next). + (described next).

    --enable-clocale=OPTION

    Select a target-specific underlying locale package. The - choices are 'ieee_1003.1-2001' to specify an X/Open, Standard Unix - (IEEE Std. 1003.1-2001) model based on langinfo/iconv/catgets, - 'gnu' to specify a model based on functionality from the GNU C - library (langinfo/iconv/gettext) (from glibc, the GNU C - library), or 'generic' to use a generic "C" - abstraction which consists of "C" locale info. + choices are 'ieee_1003.1-2001' to specify an X/Open, Standard Unix + (IEEE Std. 1003.1-2001) model based on langinfo/iconv/catgets, + 'gnu' to specify a model based on functionality from the GNU C + library (langinfo/iconv/gettext) (from glibc, the GNU C + library), or 'generic' to use a generic "C" + abstraction which consists of "C" locale info.

    If not explicitly specified, the configure proccess tries to guess the most suitable package from the choices above. The default is 'generic'. On glibc-based systems of sufficient @@ -63,124 +63,124 @@ FR locale data), 'gnu' is automatically selected. This option can change the library ABI.

    --enable-libstdcxx-allocator

    This is an abbreviated form of - '--enable-libstdcxx-allocator=auto' (described - next). + '--enable-libstdcxx-allocator=auto' (described + next).

    --enable-libstdcxx-allocator=OPTION

    Select a target-specific underlying std::allocator. The - choices are 'new' to specify a wrapper for new, 'malloc' to - specify a wrapper for malloc, 'mt' for a fixed power of two allocator, + choices are 'new' to specify a wrapper for new, 'malloc' to + specify a wrapper for malloc, 'mt' for a fixed power of two allocator, 'pool' for the SGI pooled allocator or 'bitmap' for a bitmap allocator. - See this page for more information on allocator - extensions. This option - can change the library ABI. + See this page for more information on allocator + extensions. This option + can change the library ABI.

    --enable-cheaders=OPTION

    This allows the user to define the approach taken for C header - compatibility with C++. Options are c, c_std, and c_global. - These correspond to the source directory's include/c, - include/c_std, and include/c_global, and may also include - include/c_compatibility. The default is 'c_global'. + compatibility with C++. Options are c, c_std, and c_global. + These correspond to the source directory's include/c, + include/c_std, and include/c_global, and may also include + include/c_compatibility. The default is 'c_global'.

    --enable-threads

    This is an abbreviated form of '--enable-threads=yes' - (described next). + (described next).

    --enable-threads=OPTION

    Select a threading library. A full description is - given in the - general compiler - configuration instructions. This option can change the - library ABI. + given in the + general compiler + configuration instructions. This option can change the + library ABI.

    --enable-libstdcxx-debug

    Build separate debug libraries in addition to what is normally built. - By default, the debug libraries are compiled with - CXXFLAGS='-g3 -O0 -fno-inline' - , are installed in ${libdir}/debug, and have the - same names and versioning information as the non-debug - libraries. This option is off by default. + By default, the debug libraries are compiled with + CXXFLAGS='-g3 -O0 -fno-inline' + , are installed in ${libdir}/debug, and have the + same names and versioning information as the non-debug + libraries. This option is off by default.

    Note this make command, executed in - the build directory, will do much the same thing, without the - configuration difference and without building everything twice: - make CXXFLAGS='-g3 -O0 -fno-inline' all + the build directory, will do much the same thing, without the + configuration difference and without building everything twice: + make CXXFLAGS='-g3 -O0 -fno-inline' all

    --enable-libstdcxx-debug-flags=FLAGS

    This option is only valid when --enable-debug - is also specified, and applies to the debug builds only. With - this option, you can pass a specific string of flags to the - compiler to use when building the debug versions of libstdc++. - FLAGS is a quoted string of options, like + is also specified, and applies to the debug builds only. With + this option, you can pass a specific string of flags to the + compiler to use when building the debug versions of libstdc++. + FLAGS is a quoted string of options, like 

       --enable-libstdcxx-debug-flags='-g3 -O1 -fno-inline'
    --enable-cxx-flags=FLAGS

    With this option, you can pass a string of -f (functionality) - flags to the compiler to use when building libstdc++. This - option can change the library ABI. FLAGS is a quoted string of - options, like + flags to the compiler to use when building libstdc++. This + option can change the library ABI. FLAGS is a quoted string of + options, like 

       --enable-cxx-flags='-fvtable-gc -fomit-frame-pointer -ansi'

    - Note that the flags don't necessarily have to all be -f flags, - as shown, but usually those are the ones that will make sense - for experimentation and configure-time overriding. + Note that the flags don't necessarily have to all be -f flags, + as shown, but usually those are the ones that will make sense + for experimentation and configure-time overriding.

    The advantage of --enable-cxx-flags over setting CXXFLAGS in - the 'make' environment is that, if files are automatically - rebuilt, the same flags will be used when compiling those files - as well, so that everything matches. + the 'make' environment is that, if files are automatically + rebuilt, the same flags will be used when compiling those files + as well, so that everything matches.

    Fun flags to try might include combinations of 

       -fstrict-aliasing
   -fno-exceptions
   -ffunction-sections
   -fvtable-gc

    and opposite forms (-fno-) of the same. Tell us (the libstdc++ - mailing list) if you discover more! + mailing list) if you discover more!

    --enable-c99

    The "long long" type was introduced in C99, along - with many other functions for wide characters, and math - classification macros, etc. If enabled, all C99 functions not - specified by the C++ standard will be put into namespace - __gnu_cxx, and then all these names will - be injected into namespace std, so that C99 functions can be - used "as if" they were in the C++ standard (as they - will eventually be in some future revision of the standard, - without a doubt). By default, C99 support is on, assuming the - configure probes find all the necessary functions and bits - necessary. This option can change the library ABI. + with many other functions for wide characters, and math + classification macros, etc. If enabled, all C99 functions not + specified by the C++ standard will be put into namespace + __gnu_cxx, and then all these names will + be injected into namespace std, so that C99 functions can be + used "as if" they were in the C++ standard (as they + will eventually be in some future revision of the standard, + without a doubt). By default, C99 support is on, assuming the + configure probes find all the necessary functions and bits + necessary. This option can change the library ABI.

    --enable-wchar_t[default]

    Template specializations for the "wchar_t" type are - required for wide character conversion support. Disabling - wide character specializations may be expedient for initial - porting efforts, but builds only a subset of what is required by - ISO, and is not recommended. By default, this option is on. - This option can change the library ABI. + required for wide character conversion support. Disabling + wide character specializations may be expedient for initial + porting efforts, but builds only a subset of what is required by + ISO, and is not recommended. By default, this option is on. + This option can change the library ABI.

    --enable-long-long

    The "long long" type was introduced in C99. It is - provided as a GNU extension to C++98 in g++. This flag builds - support for "long long" into the library (specialized - templates and the like for iostreams). This option is on by default: - if enabled, users will have to either use the new-style "C" - headers by default (i.e., <cmath> not <math.h>) - or add appropriate compile-time flags to all compile lines to - allow "C" visibility of this feature (on GNU/Linux, - the flag is -D_ISOC99_SOURCE, which is added automatically via - CPLUSPLUS_CPP_SPEC's addition of _GNU_SOURCE). - This option can change the library ABI. + provided as a GNU extension to C++98 in g++. This flag builds + support for "long long" into the library (specialized + templates and the like for iostreams). This option is on by default: + if enabled, users will have to either use the new-style "C" + headers by default (i.e., <cmath> not <math.h>) + or add appropriate compile-time flags to all compile lines to + allow "C" visibility of this feature (on GNU/Linux, + the flag is -D_ISOC99_SOURCE, which is added automatically via + CPLUSPLUS_CPP_SPEC's addition of _GNU_SOURCE). + This option can change the library ABI.

    --enable-fully-dynamic-string

    This option enables a special version of basic_string avoiding - the optimization that allocates empty objects in static memory. + the optimization that allocates empty objects in static memory. Mostly useful together with shared memory allocators, see PR libstdc++/16612 for details.

    --enable-concept-checks

    This turns on additional compile-time checks for instantiated - library templates, in the form of specialized templates, - described here. They - can help users discover when they break the rules of the STL, before - their programs run. + library templates, in the form of specialized templates, + described here. They + can help users discover when they break the rules of the STL, before + their programs run.

    --enable-symvers[=style]

    In 3.1 and later, tries to turn on symbol versioning in the - shared library (if a shared library has been - requested). Values for 'style' that are currently supported - are 'gnu', 'gnu-versioned-namespace', 'darwin', and - 'darwin-export'. Both gnu- options require that a recent - version of the GNU linker be in use. Both darwin options are - equivalent. With no style given, the configure script will try - to guess correct defaults for the host system, probe to see if - additional requirements are necessary and present for - activation, and if so, will turn symbol versioning on. This - option can change the library ABI. + shared library (if a shared library has been + requested). Values for 'style' that are currently supported + are 'gnu', 'gnu-versioned-namespace', 'darwin', and + 'darwin-export'. Both gnu- options require that a recent + version of the GNU linker be in use. Both darwin options are + equivalent. With no style given, the configure script will try + to guess correct defaults for the host system, probe to see if + additional requirements are necessary and present for + activation, and if so, will turn symbol versioning on. This + option can change the library ABI.

    --enable-visibility

    In 4.2 and later, enables or disables visibility attributes. - If enabled (as by default), and the compiler seems capable of - passing the simple sanity checks thrown at it, adjusts items - in namespace std, namespace std::tr1, and namespace __gnu_cxx - so that -fvisibility options work. + If enabled (as by default), and the compiler seems capable of + passing the simple sanity checks thrown at it, adjusts items + in namespace std, namespace std::tr1, and namespace __gnu_cxx + so that -fvisibility options work.

    --enable-libstdcxx-pch

    In 3.4 and later, tries to turn on the generation of - stdc++.h.gch, a pre-compiled file including all the standard - C++ includes. If enabled (as by default), and the compiler - seems capable of passing the simple sanity checks thrown at - it, try to build stdc++.h.gch as part of the make process. - In addition, this generated file is used later on (by appending - --include bits/stdc++.h to CXXFLAGS) when running the - testsuite. + stdc++.h.gch, a pre-compiled file including all the standard + C++ includes. If enabled (as by default), and the compiler + seems capable of passing the simple sanity checks thrown at + it, try to build stdc++.h.gch as part of the make process. + In addition, this generated file is used later on (by appending + --include bits/stdc++.h to CXXFLAGS) when running the + testsuite.

    --disable-hosted-libstdcxx

    By default, a complete hosted C++ library is built. The C++ Standard also describes a @@ -188,17 +188,17 @@ minimal set of headers are provided. This option builds such an environment.

    --enable-libstdcxx-time

    This is an abbreviated form of - '--enable-libstdcxx-time=yes'(described next). + '--enable-libstdcxx-time=yes'(described next).

    --enable-libstdcxx-time=OPTION

    Enables link-type checks for the availability of the - clock_gettime clocks, used in the implementation of [time.clock], - and of the nanosleep and sched_yield functions, used in the - implementation of [thread.thread.this] of the current C++0x draft. - The choice OPTION=yes checks for the availability of the facilities - in libc and libposix4. In case of need the latter is also linked - to libstdc++ as part of the build process. OPTION=rt also searches - (and, in case, links) librt. Note that the latter is not always - desirable because, in glibc, for example, in turn it triggers the - linking of libpthread too, which activates locking, a large overhead - for single-thread programs. OPTION=no skips the tests completely. - The default is OPTION=no. + clock_gettime clocks, used in the implementation of [time.clock], + and of the nanosleep and sched_yield functions, used in the + implementation of [thread.thread.this] of the current C++0x draft. + The choice OPTION=yes checks for the availability of the facilities + in libc and libposix4. In case of need the latter is also linked + to libstdc++ as part of the build process. OPTION=rt also searches + (and, in case, links) librt. Note that the latter is not always + desirable because, in glibc, for example, in turn it triggers the + linking of libpthread too, which activates locking, a large overhead + for single-thread programs. OPTION=no skips the tests completely. + The default is OPTION=no.

    Prev Up Next
    Chapter 2. Setup Home Make
    diff --git a/libstdc++-v3/doc/html/manual/containers.html b/libstdc++-v3/doc/html/manual/containers.html dissimilarity index 87% index ff94f4751e5..4aceb1bbedc 100644 --- a/libstdc++-v3/doc/html/manual/containers.html +++ b/libstdc++-v3/doc/html/manual/containers.html @@ -1,9 +1,55 @@ - - -Part VII.  Containers
    Part VII.  - Containers - -
    Prev The GNU C++ Library Next

    Part VII.  - Containers - -

    Table of Contents

    16. Sequences
    list
    list::size() is O(n)
    vector
    Space Overhead Management
    17. Associative
    Insertion Hints
    bitset
    Size Variable
    Type String
    18. Interacting with C
    Containers vs. Arrays
    Prev Up Next
    messages Home Chapter 16. Sequences
    + + +Chapter 9.  Containers
    Chapter 9.  + Containers + +
    Prev Part II.  + Standard Contents + Next

    Chapter 9.  + Containers + +

    Table of Contents

    Sequences
    list
    vector
    Associative
    Insertion Hints
    bitset
    Interacting with C
    Containers vs. Arrays

    Sequences

    list

    list::size() is O(n)

    + Yes it is, and that's okay. This is a decision that we preserved + when we imported SGI's STL implementation. The following is + quoted from their FAQ: +

    + The size() member function, for list and slist, takes time + proportional to the number of elements in the list. This was a + deliberate tradeoff. The only way to get a constant-time + size() for linked lists would be to maintain an extra member + variable containing the list's size. This would require taking + extra time to update that variable (it would make splice() a + linear time operation, for example), and it would also make the + list larger. Many list algorithms don't require that extra + word (algorithms that do require it might do better with + vectors than with lists), and, when it is necessary to maintain + an explicit size count, it's something that users can do + themselves. +

    + This choice is permitted by the C++ standard. The standard says + that size() “should” be constant time, and + “should” does not mean the same thing as + “shall”. This is the officially recommended ISO + wording for saying that an implementation is supposed to do + something unless there is a good reason not to. +

    + One implication of linear time size(): you should never write + 

    +	 if (L.size() == 0)
+	     ...
+

    + Instead, you should write + 

    +	 if (L.empty())
+	     ...
+

    vector

    +

    Space Overhead Management

    + In this + message to the list, Daniel Kostecky announced work on an + alternate form of std::vector that would support + hints on the number of elements to be over-allocated. The design + was also described, along with possible implementation choices. +

    + The first two alpha releases were announced here + and here. +

    Prev Up Next
    Facets Home Associative
    diff --git a/libstdc++-v3/doc/html/manual/containers_and_c.html b/libstdc++-v3/doc/html/manual/containers_and_c.html index 3f658590f44..4967255c4ce 100644 --- a/libstdc++-v3/doc/html/manual/containers_and_c.html +++ b/libstdc++-v3/doc/html/manual/containers_and_c.html @@ -1,9 +1,9 @@ -Chapter 18. Interacting with C
    Chapter 18. Interacting with C
    Prev Part VII.  +Interacting with C
    Interacting with C
    Prev Chapter 9.  Containers - Next

    Chapter 18. Interacting with C

    Table of Contents

    Containers vs. Arrays

    Containers vs. Arrays

    +

    		 Next

    Interacting with C

    Containers vs. Arrays

    You're writing some code and can't decide whether to use builtin arrays or some kind of container. There are compelling reasons to use one of the container classes, but you're afraid that @@ -18,7 +18,7 @@ container classes, these are iterators (usually begin() and end(), but not always). For builtin arrays, these are the address of the first element - and the past-the-end element. + and the past-the-end element.

    Some very simple wrapper functions can hide all of that from the rest of the code. For example, a pair of functions called @@ -48,27 +48,27 @@ template<typename T> { return v.begin(); } template<typename T, unsigned int sz> - inline T* + inline T* beginof(T (&array)[sz]) { return array; } // endof template<typename T> - inline typename vector<T>::iterator + inline typename vector<T>::iterator endof(vector<T> &v) { return v.end(); } template<typename T, unsigned int sz> - inline T* + inline T* endof(T (&array)[sz]) { return array + sz; } // lengthof template<typename T> - inline typename vector<T>::size_type + inline typename vector<T>::size_type lengthof(vector<T> &v) { return v.size(); } template<typename T, unsigned int sz> - inline unsigned int + inline unsigned int lengthof(T (&)[sz]) { return sz; }

    Astute readers will notice two things at once: first, that the @@ -81,10 +81,10 @@ template<typename T, unsigned int sz>

    Second, the line 

    -    inline unsigned int lengthof (T (&)[sz]) { return sz; } 
+    inline unsigned int lengthof (T (&)[sz]) { return sz; }

    looks just weird! Hint: unused parameters can be left nameless. -

    Prev Up Next
    bitset Home Part VIII.  +

    Prev Up Next
    Associative Home Chapter 10.  Iterators
    diff --git a/libstdc++-v3/doc/html/manual/debug.html b/libstdc++-v3/doc/html/manual/debug.html index e05fb66b802..9a16afd14d2 100644 --- a/libstdc++-v3/doc/html/manual/debug.html +++ b/libstdc++-v3/doc/html/manual/debug.html @@ -1,10 +1,10 @@ -Debugging Support
    Debugging Support
    Prev Chapter 3. Using Next

    Debugging Support

    +Debugging Support

    Debugging Support
    Prev Chapter 3. Using Next

    Debugging Support

    There are numerous things that can be done to improve the ease with which C++ binaries are debugged when using the GNU tool chain. Here are some of them. -

    Using g++

    +

    Using g++

    Compiler flags determine how debug information is transmitted between compilation and debug or analysis tools.

    @@ -46,13 +46,13 @@ separate directory tree, in (prefix)/lib/debug. For more information, look at the configuration section.

    - A second approach is to use the configuration flags + A second approach is to use the configuration flags 

          make CXXFLAGS='-g3 -fno-inline -O0' all

    This quick and dirty approach is often sufficient for quick debugging tasks, when you cannot or don't want to recompile your - application to use the debug mode.

    Memory Leak Hunting

    + application to use the debug mode.

    Memory Leak Hunting

    There are various third party memory tracing and debug utilities that can be used to provide detailed memory allocation information about C++ code. An exhaustive list of tools is not going to be @@ -111,17 +111,17 @@ int main() { extern void* __dso_handle __attribute__ ((__weak__)); - __cxa_atexit((void (*) (void *)) __libc_freeres, NULL, - &__dso_handle ? __dso_handle : NULL); + __cxa_atexit((void (*) (void *)) __libc_freeres, NULL, + &__dso_handle ? __dso_handle : NULL); do_test(); return 0; }

    Suggested valgrind flags, given the suggestions above about setting up the runtime environment, library, and test file, might be: -

     
+
        valgrind -v --num-callers=20 --leak-check=yes --leak-resolution=high --show-reachable=yes a.out
-

    Using gdb

    +

    Using gdb

    Many options are available for gdb itself: please see "GDB features for C++" in the gdb documentation. Also @@ -145,7 +145,7 @@ To enable these printers, check-out the latest printers to a local directory: 

    -  svn co svn://gcc.gnu.org/svn/gcc/trunk/libstdc++-v3/python 
+  svn co svn://gcc.gnu.org/svn/gcc/trunk/libstdc++-v3/python

    Next, add the following section to your ~/.gdbinit The path must match the location where the Python module above was checked-out. @@ -175,18 +175,17 @@ "GDB: The GNU Project Debugger" .

    Tracking uncaught exceptions

    - The verbose + The verbose termination handler gives information about uncaught exceptions which are killing the program. It is described in the linked-to page. -

    Debug Mode

    The Debug Mode +

    Debug Mode

    The Debug Mode has compile and run-time checks for many containers. -

    Compile Time Checking

    The Compile-Time +

    Compile Time Checking

    The Compile-Time Checks Extension has compile-time checks for many algorithms. -

    Profile-based Performance Analysis

    The Profile-based - Performance Analysis Extension has performance checks for many +

    Profile-based Performance Analysis

    The Profile-based + Performance Analysis Extension has performance checks for many algorithms. -

    Prev Up Next
    Exceptions Home Part II.  - Support - +

    Prev Up Next
    Exceptions Home Part II.  + Standard Contents
    diff --git a/libstdc++-v3/doc/html/manual/debug_mode.html b/libstdc++-v3/doc/html/manual/debug_mode.html index 9231ca944b7..fcaeb9c5209 100644 --- a/libstdc++-v3/doc/html/manual/debug_mode.html +++ b/libstdc++-v3/doc/html/manual/debug_mode.html @@ -1,9 +1,9 @@ -Chapter 30. Debug Mode
    Chapter 30. Debug Mode
    Prev Part XII.  +Chapter 17. Debug Mode
    Chapter 17. Debug Mode
    Prev Part III.  Extensions - Next

    Chapter 30. Debug Mode

    Table of Contents

    Intro
    Semantics
    Using
    Using the Debug Mode
    Using a Specific Debug Container
    Design
    Goals
    Methods
    Other Implementations

    Intro

    +

    		 Next

    Chapter 17. Debug Mode

    Table of Contents

    Intro
    Semantics
    Using
    Using the Debug Mode
    Using a Specific Debug Container
    Design
    Goals
    Methods
    Other Implementations

    Intro

    By default, libstdc++ is built with efficiency in mind, and therefore performs little or no error checking that is not required by the C++ standard. This means that programs that @@ -15,7 +15,7 @@ library facilities, and will report errors in the use of libstdc++ as soon as they can be detected by emitting a description of the problem to standard error and aborting the program. This debug - mode is available with GCC 3.4.0 and later versions. + mode is available with GCC 3.4.0 and later versions.

    The libstdc++ debug mode performs checking for many areas of the C++ standard, but the focus is on checking interactions among @@ -34,4 +34,4 @@ the same predicate that was passed to set_intersection; the libstdc++ debug mode will detect an error if the sequence is not sorted or was sorted by a - different predicate.

    Prev Up Next
    Chapter 29. Compile Time Checks Home Semantics
    + different predicate.

    Prev Up Next
    Chapter 16. Compile Time Checks Home Semantics
    diff --git a/libstdc++-v3/doc/html/manual/diagnostics.html b/libstdc++-v3/doc/html/manual/diagnostics.html dissimilarity index 86% index 746a9f4185a..d04585fbcd9 100644 --- a/libstdc++-v3/doc/html/manual/diagnostics.html +++ b/libstdc++-v3/doc/html/manual/diagnostics.html @@ -1,9 +1,43 @@ - - -Part III.  Diagnostics
    Part III.  - Diagnostics - -
    Prev The GNU C++ Library Next

    Part III.  - Diagnostics - -

    Table of Contents

    7. Exceptions
    Exception Classes
    Adding Data to Exceptions
    8. Concept Checking
    Prev Up Next
    Verbose Terminate Handler Home Chapter 7. Exceptions
    + + +Chapter 5.  Diagnostics
    Chapter 5.  + Diagnostics + +
    Prev Part II.  + Standard Contents + Next

    Chapter 5.  + Diagnostics + +

    Table of Contents

    Exceptions
    API Reference
    Adding Data to exception
    Concept Checking

    Exceptions

    API Reference

    + All exception objects are defined in one of the standard header + files: exception, + stdexcept, new, and + typeinfo. +

    + The base exception object is exception, + located in exception. This object has no + string member. +

    + Derived from this are several classes that may have a + string member: a full hierarchy can be + found in the source documentation. +

    + Full API details. +

    Adding Data to exception

    + The standard exception classes carry with them a single string as + data (usually describing what went wrong or where the 'throw' took + place). It's good to remember that you can add your own data to + these exceptions when extending the hierarchy: + 

    +   struct My_Exception : public std::runtime_error
+   {
+     public:
+       My_Exception (const string& whatarg)
+	   : std::runtime_error(whatarg), e(errno), id(GetDataBaseID()) { }
+       int  errno_at_time_of_throw() const { return e; }
+       DBID id_of_thing_that_threw() const { return id; }
+     protected:
+       int    e;
+       DBID   id;     // some user-defined type
+   };
+
    Prev Up Next
    Termination Home Concept Checking
    diff --git a/libstdc++-v3/doc/html/manual/documentation_style.html b/libstdc++-v3/doc/html/manual/documentation_style.html index 39c0b446a97..e32947a2626 100644 --- a/libstdc++-v3/doc/html/manual/documentation_style.html +++ b/libstdc++-v3/doc/html/manual/documentation_style.html @@ -4,25 +4,29 @@ Contributing     		 Next

    Documentation Style

    Doxygen

    Prerequisites

    - Prerequisite tools are Bash 2.x, + Prerequisite tools are Bash 2.x or higher, Doxygen, and the GNU coreutils. (GNU versions of find, xargs, and possibly sed and grep are used, just because the GNU versions make - things very easy.) + things very easy.)

    To generate the pretty pictures and hierarchy graphs, the - Graphviz - package will need to be installed. + Graphviz package + will need to be installed. For PDF + output, + pdflatex is required.

    Generating the Doxygen Files

    The following Makefile rules run Doxygen to generate HTML - docs, XML docs, and the man pages. + docs, XML docs, PDF docs, and the man pages. 

    make doc-html-doxygen

    make doc-xml-doxygen

    + 

    make doc-pdf-doxygen

    + 

    make doc-man-doxygen

    Careful observers will see that the Makefile rules simply call @@ -64,7 +68,7 @@ ...not the Qt style. The intermediate *'s are preferred.

  • Use the triple-slash style only for one-line comments (the - “brief” mode). + “brief” mode).

  • This is disgusting. Don't do this.

    • @@ -95,7 +99,7 @@    * @brief A model of a linear congruential random number generator.
       *
       * @f[
    -   *     x_{i+1}\leftarrow(ax_{i} + c) \bmod m 
    +   *     x_{i+1}\leftarrow(ax_{i} + c) \bmod m
       * @f]
       */

    @@ -104,7 +108,7 @@ writing Doxygen comments. Single and double quotes, and separators in filenames are two common trouble spots. When in doubt, consult the following table. -

    Table A.1. HTML to Doxygen markup comparison

    HTMLDoxygen
    \\\
    "\"
    '\'
    <i>@a word
    <b>@b word
    <code>@c word
    <em>@a word
    <em><em>two words or more</em>

    Docbook

    Prerequisites

    +

    Table A.1. HTML to Doxygen Markup Comparison

    HTMLDoxygen
    \\\
    "\"
    '\'
    <i>@a word
    <b>@b word
    <code>@c word
    <em>@a word
    <em><em>two words or more</em>

    Docbook

    Prerequisites

    Editing the DocBook sources requires an XML editor. Many exist: some notable options include emacs, Kate, @@ -139,33 +143,35 @@ by a vendor package like libxml2.

    For PDF output, something that transforms valid XML to PDF is - required. Possible solutions include xmlto, - Apache - FOP, or prince. Other options are - listed on the DocBook web pages. Please + required. Possible solutions include + dblatex, + xmlto, or prince. Other + options are listed on the DocBook + web pages. Please consult the list when - preparing printed manuals for current best practice and suggestions. + preparing printed manuals for current best practice and + suggestions.

    Make sure that the XML documentation and markup is valid for any change. This can be done easily, with the validation rules - in the Makefile, which is equivalent to doing: + in the Makefile, which is equivalent to doing: 

     	  
 xmllint --noout --valid xml/index.xml

    Generating the DocBook Files

    The following Makefile rules generate (in order): an HTML - version of all the documentation, a PDF version of the same, a + version of all the DocBook documentation, a PDF version of the same, a single XML document, and the result of validating the entire XML document.

    - 

    make doc-html

    + 

    make doc-html-docbook

    - 

    make doc-pdf

    + 

    make doc-pdf-docbook

    - 

    make doc-xml-single

    + 

    make doc-xml-single-docbook

    - 

    make doc-xml-validate

    + 

    make doc-xml-validate-docbook

    File Organization and Basics


          Which files are important

    @@ -173,11 +179,11 @@ xmllint --noout --valid xml/index.xml       libstdc++-v3/doc/xml

          Inside this directory, the files of importance:
    -      spine.xml   - index to documentation set
    +      spine.xml   - index to documentation set
          manual/spine.xml  - index to manual
          manual/*.xml   - individual chapters and sections of the manual
          faq.xml   - index to FAQ
    -      api.xml   - index to source level / API 
    +      api.xml   - index to source level / API

          All *.txml files are template xml files, i.e., otherwise empty files with
          the correct structure, suitable for filling in with new information.
    @@ -205,7 +211,7 @@ xmllint --noout --valid xml/index.xml       </chapter>
          </book>

    -      <book>
    +      <book>
          <part>
          <chapter>
          <section>
    @@ -222,20 +228,21 @@ xmllint --noout --valid xml/index.xml
          <chapter>
          </chapter>
    -      </part>  
    +      </part>
          </book>

          </set>
        

    Markup By Example

    -Complete details on Docbook markup can be found in the DocBook Element -Reference, online. An -incomplete reference for HTML to Docbook conversion is detailed in the -table below. -

    Table A.2. HTML to Docbook XML markup comparison

    HTMLDocbook
    <p><para>
    <pre><computeroutput>, <programlisting>, + Complete details on Docbook markup can be found in the DocBook + Element Reference, + online. + An incomplete reference for HTML to Docbook conversion is + detailed in the table below. +

    Table A.2. HTML to Docbook XML Markup Comparison

    HTMLDocbook
    <p><para>
    <pre><computeroutput>, <programlisting>, <literallayout>
    <ul><itemizedlist>
    <ol><orderedlist>
    <il><listitem>
    <dl><variablelist>
    <dt><term>
    <dd><listitem>
    <a href=""><ulink url="">
    <code><literal>, <programlisting>
    <strong><emphasis>
    <em><emphasis>
    "<quote>

    And examples of detailed markup for which there are no real HTML equivalents are listed in the table below. -

    Table A.3. Docbook XML Element Use

    ElementUse
    <structname><structname>char_traits</structname>
    <classname><classname>string</classname>
    <function> +

    Table A.3. Docbook XML Element Use

    ElementUse
    <structname><structname>char_traits</structname>
    <classname><classname>string</classname>
    <function>

    <function>clear()</function>

    <function>fs.clear()</function>

    <type><type>long long</type>
    <varname><varname>fs</varname>
    <literal> @@ -248,4 +255,13 @@ table below.

    <filename class="headerfile">ctype.h</filename>

    <filename class="directory">/home/gcc/build</filename>

    <filename class="libraryfile">libstdc++.so</filename>

    -

    Prev Up Next
    Coding Style Home Design Notes
    +

    Combines

    Generating Combines and Assemblages

    + The following Makefile rules are defaults, and are usually + aliased to variable rules. +

    + 

    make doc-html

    +

    + 

    make doc-man

    +

    + 

    make doc-pdf

    +

    Prev Up Next
    Coding Style Home Design Notes
    diff --git a/libstdc++-v3/doc/html/manual/dynamic_memory.html b/libstdc++-v3/doc/html/manual/dynamic_memory.html index e23fdf5c272..4403ae80a5a 100644 --- a/libstdc++-v3/doc/html/manual/dynamic_memory.html +++ b/libstdc++-v3/doc/html/manual/dynamic_memory.html @@ -1,9 +1,9 @@ -Chapter 5. Dynamic Memory
    Chapter 5. Dynamic Memory
    Prev Part II.  +Dynamic Memory
    Dynamic Memory
    Prev Chapter 4.  Support - Next

    Chapter 5. Dynamic Memory

    +

    		 Next

    Dynamic Memory

    There are six flavors each of new and delete, so make certain that you're using the right ones. Here are quickie descriptions of new: @@ -51,8 +51,8 @@ { delete[] safety; popup_window ("Dude, you are running low on heap memory. You - should, like, close some windows, or something. - The next time you run out, we're gonna burn!"); + should, like, close some windows, or something. + The next time you run out, we're gonna burn!"); set_new_handler (old_handler); return; } @@ -65,5 +65,8 @@ }

    bad_alloc is derived from the base exception - class defined in Chapter 19. -

    Prev Up Next
    NULL Home Chapter 6. Termination
    + class defined in Sect1 19. +

    Prev Up Next
    Chapter 4.  + Support + + Home Termination
    diff --git a/libstdc++-v3/doc/html/manual/exceptions.html b/libstdc++-v3/doc/html/manual/exceptions.html deleted file mode 100644 index 3e6b12b93e4..00000000000 --- a/libstdc++-v3/doc/html/manual/exceptions.html +++ /dev/null @@ -1,22 +0,0 @@ - - -Chapter 7. Exceptions
    Chapter 7. Exceptions
    Prev Part III.  - Diagnostics - - Next

    Chapter 7. Exceptions

    Table of Contents

    Exception Classes
    Adding Data to Exceptions

    Exception Classes

    - All exception objects are defined in one of the standard header - files: exception, - stdexcept, new, and - typeinfo. -

    - The base exception object is exception, - located in exception. This object has no - string member. -

    - Derived from this are several classes that may have a - string member: a full hierarchy can be - found in the source documentation. -

    Prev Up Next
    Part III.  - Diagnostics - - Home Adding Data to Exceptions
    diff --git a/libstdc++-v3/doc/html/manual/ext_algorithms.html b/libstdc++-v3/doc/html/manual/ext_algorithms.html index 02231d43e4d..1b42f7da28e 100644 --- a/libstdc++-v3/doc/html/manual/ext_algorithms.html +++ b/libstdc++-v3/doc/html/manual/ext_algorithms.html @@ -1,9 +1,9 @@ -Chapter 36. Algorithms
    Chapter 36. Algorithms
    Prev Part XII.  +Chapter 23. Algorithms
    Chapter 23. Algorithms
    Prev Part III.  Extensions - Next

    Chapter 36. Algorithms

    25.1.6 (count, count_if) is extended with two more versions of count +

    		 Next

    Chapter 23. Algorithms

    25.1.6 (count, count_if) is extended with two more versions of count and count_if. The standard versions return their results. The additional signatures return void, but take a final parameter by reference to which they assign their results, e.g., @@ -16,8 +16,8 @@

    25.3 (sorting 'n' heaps 'n' stuff) is extended with some helper predicates. Look in the doxygen-generated pages for notes on these.

    • is_heap tests whether or not a range is a heap.

    • is_sorted tests whether or not a range is sorted in - nondescending order.

    25.3.8 (lexicographical_compare) is extended with + nondescending order.

    25.3.8 (lexicographical_compare) is extended with 

        lexicographical_compare_3way(_InputIter1 first1, _InputIter1 last1,
-                                 _InputIter2 first2, _InputIter2 last2)

    which does... what? -

    Prev Up Next
    Chapter 35. Utilities Home Chapter 37. Numerics
    + _InputIter2 first2, _InputIter2 last2)

    which does... what? +

    Prev Up Next
    Chapter 22. Utilities Home Chapter 24. Numerics
    diff --git a/libstdc++-v3/doc/html/manual/ext_allocators.html b/libstdc++-v3/doc/html/manual/ext_allocators.html index bbb5300fb2b..37bed0b14f7 100644 --- a/libstdc++-v3/doc/html/manual/ext_allocators.html +++ b/libstdc++-v3/doc/html/manual/ext_allocators.html @@ -1,10 +1,10 @@ -Chapter 33. Allocators
    Chapter 33. Allocators
    Prev Part XII.  +Chapter 20. Allocators
    Chapter 20. Allocators
    Prev Part III.  Extensions - Next

    Chapter 33. Allocators

    Table of Contents

    mt_allocator
    Intro
    Design Issues
    Implementation
    Single Thread Example
    Multiple Thread Example
    bitmap_allocator
    Design
    Implementation

    mt_allocator

    -

    Intro

    +

    		 Next

    Chapter 20. Allocators

    Table of Contents

    mt_allocator
    Intro
    Design Issues
    Implementation
    Single Thread Example
    Multiple Thread Example
    bitmap_allocator
    Design
    Implementation

    mt_allocator

    +

    Intro

    The mt allocator [hereinafter referred to simply as "the allocator"] is a fixed size (power of two) allocator that was initially developed specifically to suit the needs of multi threaded @@ -25,7 +25,7 @@ describing the characteristics of the memory pool, a policy class containing this pool that links instantiation types to common or individual pools, and a class inheriting from the policy class that is the actual allocator. -

    The datum describing pools characteristics is +

    The datum describing pools characteristics is 

       template<bool _Thread>
     class __pool
@@ -82,9 +82,9 @@ int main()
   tune_type t_single(16, 5120, 32, 5120, 1, 10, false);
 
   tune_type t;
-  t = allocator_type::_M_get_options();  
+  t = allocator_type::_M_get_options();
   allocator_type::_M_set_options(t_opt);
-  t = allocator_type::_M_get_options();  
+  t = allocator_type::_M_get_options();
 
   allocator_type a;
   allocator_type::pointer p1 = a.allocate(128);
@@ -111,18 +111,18 @@ The _S_initialize() function:
   allocate() to return memory directly from a new() call, and deallocate will
   only do a delete() call.
 
    
-- If the GLIBCXX_FORCE_NEW environment variable is not set, both ST and MT 
+- If the GLIBCXX_FORCE_NEW environment variable is not set, both ST and MT
   applications will:
   - Calculate the number of bins needed. A bin is a specific power of two size
-    of bytes. I.e., by default the allocator will deal with requests of up to 
-    128 bytes (or whatever the value of _S_max_bytes is when _S_init() is 
-    called). This means that there will be bins of the following sizes 
-    (in bytes): 1, 2, 4, 8, 16, 32, 64, 128. 
+    of bytes. I.e., by default the allocator will deal with requests of up to
+    128 bytes (or whatever the value of _S_max_bytes is when _S_init() is
+    called). This means that there will be bins of the following sizes
+    (in bytes): 1, 2, 4, 8, 16, 32, 64, 128.
 
-  - Create the _S_binmap array. All requests are rounded up to the next 
-    "large enough" bin. I.e., a request for 29 bytes will cause a block from 
-    the "32 byte bin" to be returned to the application. The purpose of 
-    _S_binmap is to speed up the process of finding out which bin to use. 
+  - Create the _S_binmap array. All requests are rounded up to the next
+    "large enough" bin. I.e., a request for 29 bytes will cause a block from
+    the "32 byte bin" to be returned to the application. The purpose of
+    _S_binmap is to speed up the process of finding out which bin to use.
     I.e., the value of _S_binmap[ 29 ] is initialized to 5 (bin 5 = 32 bytes).
 
    
   - Create the _S_bin array. This array consists of bin_records. There will be
@@ -130,35 +130,35 @@ The _S_initialize() function:
     earlier. I.e., if _S_max_bytes = 128 there will be 8 entries.
     Each bin_record is then initialized:
     - bin_record->first = An array of pointers to block_records. There will be
-      as many block_records pointers as there are maximum number of threads 
-      (in a ST application there is only 1 thread, in a MT application there 
+      as many block_records pointers as there are maximum number of threads
+      (in a ST application there is only 1 thread, in a MT application there
       are _S_max_threads).
       This holds the pointer to the first free block for each thread in this
       bin. I.e., if we would like to know where the first free block of size 32
       for thread number 3 is we would look this up by: _S_bin[ 5 ].first[ 3 ]
 
-    The above created block_record pointers members are now initialized to 
+    The above created block_record pointers members are now initialized to
     their initial values. I.e. _S_bin[ n ].first[ n ] = NULL;
 
    
 - Additionally a MT application will:
   - Create a list of free thread id's. The pointer to the first entry
-    is stored in _S_thread_freelist_first. The reason for this approach is 
-    that the __gthread_self() call will not return a value that corresponds to 
+    is stored in _S_thread_freelist_first. The reason for this approach is
+    that the __gthread_self() call will not return a value that corresponds to
     the maximum number of threads allowed but rather a process id number or
     something else. So what we do is that we create a list of thread_records.
     This list is _S_max_threads long and each entry holds a size_t thread_id
     which is initialized to 1, 2, 3, 4, 5 and so on up to _S_max_threads.
-    Each time a thread calls allocate() or deallocate() we call 
+    Each time a thread calls allocate() or deallocate() we call
     _S_get_thread_id() which looks at the value of _S_thread_key which is a
     thread local storage pointer. If this is NULL we know that this is a newly
     created thread and we pop the first entry from this list and saves the
-    pointer to this record in the _S_thread_key variable. The next time 
-    we will get the pointer to the thread_record back and we use the 
-    thread_record->thread_id as identification. I.e., the first thread that 
+    pointer to this record in the _S_thread_key variable. The next time
+    we will get the pointer to the thread_record back and we use the
+    thread_record->thread_id as identification. I.e., the first thread that
     calls allocate will get the first record in this list and thus be thread
     number 1 and will then find the pointer to its first free 32 byte block
     in _S_bin[ 5 ].first[ 1 ]
-    When we create the _S_thread_key we also define a destructor 
+    When we create the _S_thread_key we also define a destructor
     (_S_thread_key_destr) which means that when the thread dies, this
     thread_record is returned to the front of this list and the thread id
     can then be reused if a new thread is created.
@@ -176,7 +176,7 @@ The _S_initialize() function:
       has made 678 requests (and no deallocations...) of 32-byte blocks this
       counter will read 678.
 
-    The above created arrays are now initialized with their initial values. 
+    The above created arrays are now initialized with their initial values.
     I.e. _S_bin[ n ].free[ n ] = 0;
 
    
   - Initialize the mutex of each bin_record: The bin_record->mutex
@@ -260,39 +260,39 @@ This is the first two blocks in freelist for thread id 3 in bin 3 (8 bytes):
 +----------------+

    With this in mind we simplify things a bit for a while and say that there is -only one thread (a ST application). In this case all operations are made to +only one thread (a ST application). In this case all operations are made to what is referred to as the global pool - thread id 0 (No thread may be assigned this id since they span from 1 to _S_max_threads in a MT application).

    When the application requests memory (calling allocate()) we first look at the requested size and if this is > _S_max_bytes we call new() directly and return.

    -If the requested size is within limits we start by finding out from which +If the requested size is within limits we start by finding out from which bin we should serve this request by looking in _S_binmap.

    A quick look at _S_bin[ bin ].first[ 0 ] tells us if there are any blocks of this size on the freelist (0). If this is not NULL - fine, just remove the -block that _S_bin[ bin ].first[ 0 ] points to from the list, +block that _S_bin[ bin ].first[ 0 ] points to from the list, update _S_bin[ bin ].first[ 0 ] and return a pointer to that blocks data.

    -If the freelist is empty (the pointer is NULL) we must get memory from the +If the freelist is empty (the pointer is NULL) we must get memory from the system and build us a freelist within this memory. All requests for new memory -is made in chunks of _S_chunk_size. Knowing the size of a block_record and -the bytes that this bin stores we then calculate how many blocks we can create +is made in chunks of _S_chunk_size. Knowing the size of a block_record and +the bytes that this bin stores we then calculate how many blocks we can create within this chunk, build the list, remove the first block, update the pointer -(_S_bin[ bin ].first[ 0 ]) and return a pointer to that blocks data. +(_S_bin[ bin ].first[ 0 ]) and return a pointer to that blocks data.

    Deallocation is equally simple; the pointer is casted back to a block_record -pointer, lookup which bin to use based on the size, add the block to the front -of the global freelist and update the pointer as needed +pointer, lookup which bin to use based on the size, add the block to the front +of the global freelist and update the pointer as needed (_S_bin[ bin ].first[ 0 ]).

    The decision to add deallocated blocks to the front of the freelist was made after a set of performance measurements that showed that this is roughly 10% faster than maintaining a set of "last pointers" as well.

    Multiple Thread Example

    -In the ST example we never used the thread_id variable present in each block. -Let's start by explaining the purpose of this in a MT application. +In the ST example we never used the thread_id variable present in each block. +Let's start by explaining the purpose of this in a MT application.

    The concept of "ownership" was introduced since many MT applications allocate and deallocate memory to shared containers from different @@ -321,10 +321,10 @@ When the application requests memory (calling allocate()) we first look at the requested size and if this is >_S_max_bytes we call new() directly and return.

    -If the requested size is within limits we start by finding out from which +If the requested size is within limits we start by finding out from which bin we should serve this request by looking in _S_binmap.

    -A call to _S_get_thread_id() returns the thread id for the calling thread +A call to _S_get_thread_id() returns the thread id for the calling thread (and if no value has been set in _S_thread_key, a new id is assigned and returned).

    @@ -394,4 +394,4 @@ mutex to be locked) this operation is also made in chunks of blocks a threads freelist mentioned above). The "formula" used can probably be improved to further reduce the risk of blocks being "bounced back and forth" between freelists. -

    Prev Up Next
    Diagnostics Home bitmap_allocator
    +

    Prev Up Next
    Diagnostics Home bitmap_allocator
    diff --git a/libstdc++-v3/doc/html/manual/ext_compile_checks.html b/libstdc++-v3/doc/html/manual/ext_compile_checks.html index 104d81a9908..e99452bdb59 100644 --- a/libstdc++-v3/doc/html/manual/ext_compile_checks.html +++ b/libstdc++-v3/doc/html/manual/ext_compile_checks.html @@ -1,9 +1,9 @@ -Chapter 29. Compile Time Checks
    Chapter 29. Compile Time Checks
    Prev Part XII.  +Chapter 16. Compile Time Checks
    Chapter 16. Compile Time Checks
    Prev Part III.  Extensions - Next

    Chapter 29. Compile Time Checks

    +

    		 Next

    Chapter 16. Compile Time Checks

    Also known as concept checking.

    In 1999, SGI added concept checkers to their implementation of the STL: code which checked the template parameters of @@ -37,4 +37,4 @@ support for template parameter constraints based on concepts in the core language. This will obviate the need for the library-simulated concept checking described above. -

    Prev Up Next
     Home Chapter 30. Debug Mode
    +

    Prev Up Next
     Home Chapter 17. Debug Mode
    diff --git a/libstdc++-v3/doc/html/manual/ext_concurrency.html b/libstdc++-v3/doc/html/manual/ext_concurrency.html index 0d660c7402c..c9922a9b6bc 100644 --- a/libstdc++-v3/doc/html/manual/ext_concurrency.html +++ b/libstdc++-v3/doc/html/manual/ext_concurrency.html @@ -1,9 +1,9 @@ -Chapter 41. Concurrency
    Chapter 41. Concurrency
    Prev Part XII.  +Chapter 28. Concurrency
    Chapter 28. Concurrency
    Prev Part III.  Extensions - Next

    Chapter 41. Concurrency

    Table of Contents

    Design
    Interface to Locks and Mutexes
    Interface to Atomic Functions
    Implementation
    Using Builtin Atomic Functions
    Thread Abstraction
    Use

    Design

    Interface to Locks and Mutexes

    The file <ext/concurrence.h> contains all the higher-level +

    		 Next

    Chapter 28. Concurrency

    Table of Contents

    Design
    Interface to Locks and Mutexes
    Interface to Atomic Functions
    Implementation
    Using Builtin Atomic Functions
    Thread Abstraction
    Use

    Design

    Interface to Locks and Mutexes

    The file <ext/concurrence.h> contains all the higher-level constructs for playing with threads. In contrast to the atomics layer, the concurrence layer consists largely of types. All types are defined within namespace __gnu_cxx.

    @@ -31,7 +31,7 @@ locks it during construction of __scoped_locke and unlocks it during destruction. This is an efficient way of locking critical sections, while retaining exception-safety.

    Interface to Atomic Functions

    -Two functions and one type form the base of atomic support. +Two functions and one type form the base of atomic support.

    The type _Atomic_word is a signed integral type supporting atomic operations.

    @@ -56,7 +56,7 @@ __atomic_add_dispatch

    Adds the second argument's value to the first argument. Has no return value.

    These functions forward to one of several specialized helper -functions, depending on the circumstances. For instance, +functions, depending on the circumstances. For instance,

    __exchange_and_add_dispatch @@ -67,7 +67,7 @@ Calls through to either of:

    Multi-thread version. Inlined if compiler-generated builtin atomics can be used, otherwise resolved at link time to a non-builtin code sequence. -

  • __exchange_and_add_single +

  • __exchange_and_add_single

    Single threaded version. Inlined.

    • However, only __exchange_and_add_dispatch and __atomic_add_dispatch should be used. These functions can be used in a portable manner, regardless of the specific @@ -79,13 +79,13 @@ operations.) In addition, there are two macros

    -_GLIBCXX_READ_MEM_BARRIER +_GLIBCXX_READ_MEM_BARRIER

    -_GLIBCXX_WRITE_MEM_BARRIER +_GLIBCXX_WRITE_MEM_BARRIER

    Which expand to the appropriate write and read barrier required by the host hardware and operating system. -

    Prev Up Next
    Chapter 40. Demangling Home Implementation
    +

    Prev Up Next
    Chapter 27. Demangling Home Implementation
    diff --git a/libstdc++-v3/doc/html/manual/ext_containers.html b/libstdc++-v3/doc/html/manual/ext_containers.html index 5b767d27922..79fe759fcd9 100644 --- a/libstdc++-v3/doc/html/manual/ext_containers.html +++ b/libstdc++-v3/doc/html/manual/ext_containers.html @@ -1,9 +1,9 @@ -Chapter 34. Containers
    Chapter 34. Containers
    Prev Part XII.  +Chapter 21. Containers
    Chapter 21. Containers
    Prev Part III.  Extensions - Next

    Chapter 34. Containers

    Table of Contents

    Policy Based Data Structures
    HP/SGI
    Deprecated HP/SGI

    +

    		 Next

    Chapter 21. Containers

    Table of Contents

    Policy Based Data Structures
    HP/SGI
    Deprecated HP/SGI

    Policy Based Data Structures

    More details here. -

    Prev Up Next
    bitmap_allocator Home HP/SGI
    +

    Prev Up Next
    bitmap_allocator Home HP/SGI
    diff --git a/libstdc++-v3/doc/html/manual/ext_demangling.html b/libstdc++-v3/doc/html/manual/ext_demangling.html index 9214423d3b5..4a991d0313d 100644 --- a/libstdc++-v3/doc/html/manual/ext_demangling.html +++ b/libstdc++-v3/doc/html/manual/ext_demangling.html @@ -1,9 +1,9 @@ -Chapter 40. Demangling
    Chapter 40. Demangling
    Prev Part XII.  +Chapter 27. Demangling
    Chapter 27. Demangling
    Prev Part III.  Extensions - Next

    Chapter 40. Demangling

    +

    		 Next

    Chapter 27. Demangling

    Transforming C++ ABI identifiers (like RTTI symbols) into the original C++ source identifiers is called “demangling.” @@ -63,7 +63,7 @@ int main() 

        
       St13bad_exception       => std::bad_exception   : 0
-      3barI5emptyLi17EE       => bar<empty, 17>       : 0 
+      3barI5emptyLi17EE       => bar<empty, 17>       : 0

    The demangler interface is described in the source documentation @@ -71,4 +71,4 @@ int main() be writing C++ in order to demangle C++. (That also means we have to use crummy memory management facilities, so don't forget to free() the returned char array.) -

    Prev Up Next
    Chapter 39. Input and Output Home Chapter 41. Concurrency
    +

    Prev Up Next
    Chapter 26. Input and Output Home Chapter 28. Concurrency
    diff --git a/libstdc++-v3/doc/html/manual/ext_io.html b/libstdc++-v3/doc/html/manual/ext_io.html index 0afa23ddf96..0c67bf6a2e5 100644 --- a/libstdc++-v3/doc/html/manual/ext_io.html +++ b/libstdc++-v3/doc/html/manual/ext_io.html @@ -1,9 +1,9 @@ -Chapter 39. Input and Output
    Chapter 39. Input and Output
    Prev Part XII.  +Chapter 26. Input and Output
    Chapter 26. Input and Output
    Prev Part III.  Extensions - Next

    Chapter 39. Input and Output

    Table of Contents

    Derived filebufs

    +

    		 Next

    Chapter 26. Input and Output

    Table of Contents

    Derived filebufs

    Extensions allowing filebufs to be constructed from "C" types like FILE*s and file descriptors.

    Derived filebufs

    The v2 library included non-standard extensions to construct @@ -13,38 +13,38 @@ IOStreams is via the stdio_filebuf class (see below), but earlier releases provided slightly different mechanisms.

    • 3.0.x filebufs have another ctor with this signature: - basic_filebuf(__c_file_type*, ios_base::openmode, int_type); + basic_filebuf(__c_file_type*, ios_base::openmode, int_type); - This comes in very handy in a number of places, such as - attaching Unix sockets, pipes, and anything else which uses file - descriptors, into the IOStream buffering classes. The three - arguments are as follows: -

      • __c_file_type* F - // the __c_file_type typedef usually boils down to stdio's FILE -

      • ios_base::openmode M - // same as all the other uses of openmode -

      • int_type B - // buffer size, defaults to BUFSIZ if not specified -

      - For those wanting to use file descriptors instead of FILE*'s, I - invite you to contemplate the mysteries of C's fdopen(). + This comes in very handy in a number of places, such as + attaching Unix sockets, pipes, and anything else which uses file + descriptors, into the IOStream buffering classes. The three + arguments are as follows: +

      • __c_file_type* F + // the __c_file_type typedef usually boils down to stdio's FILE +

      • ios_base::openmode M + // same as all the other uses of openmode +

      • int_type B + // buffer size, defaults to BUFSIZ if not specified +

      + For those wanting to use file descriptors instead of FILE*'s, I + invite you to contemplate the mysteries of C's fdopen().

    • In library snapshot 3.0.95 and later, filebufs bring - back an old extension: the fd() member function. The - integer returned from this function can be used for whatever file - descriptors can be used for on your platform. Naturally, the - library cannot track what you do on your own with a file descriptor, - so if you perform any I/O directly, don't expect the library to be - aware of it. + back an old extension: the fd() member function. The + integer returned from this function can be used for whatever file + descriptors can be used for on your platform. Naturally, the + library cannot track what you do on your own with a file descriptor, + so if you perform any I/O directly, don't expect the library to be + aware of it.

    • Beginning with 3.1, the extra filebuf constructor and - the fd() function were removed from the standard - filebuf. Instead, <ext/stdio_filebuf.h> contains - a derived class called - __gnu_cxx::stdio_filebuf. - This class can be constructed from a C FILE* or a file - descriptor, and provides the fd() function. + the fd() function were removed from the standard + filebuf. Instead, <ext/stdio_filebuf.h> contains + a derived class called + __gnu_cxx::stdio_filebuf. + This class can be constructed from a C FILE* or a file + descriptor, and provides the fd() function.

    If you want to access a filebuf's file descriptor to implement file locking (e.g. using the fcntl() system call) then you might be interested in Henry Suter's RWLock class.

    -

    Prev Up Next
    Chapter 38. Iterators Home Chapter 40. Demangling
    +

    Prev Up Next
    Chapter 25. Iterators Home Chapter 27. Demangling
    diff --git a/libstdc++-v3/doc/html/manual/ext_iterators.html b/libstdc++-v3/doc/html/manual/ext_iterators.html index 88259a8ace9..5f5a5348547 100644 --- a/libstdc++-v3/doc/html/manual/ext_iterators.html +++ b/libstdc++-v3/doc/html/manual/ext_iterators.html @@ -1,9 +1,9 @@ -Chapter 38. Iterators
    Chapter 38. Iterators
    Prev Part XII.  +Chapter 25. Iterators
    Chapter 25. Iterators
    Prev Part III.  Extensions - Next

    Chapter 38. Iterators

    24.3.2 describes struct iterator, which didn't exist in the +

    		 Next

    Chapter 25. Iterators

    24.3.2 describes struct iterator, which didn't exist in the original HP STL implementation (the language wasn't rich enough at the time). For backwards compatibility, base classes are provided which declare the same nested typedefs: @@ -11,4 +11,4 @@ two iterators and returns a result. It is extended by another signature which takes two iterators and a reference to a result. The result is modified, and the function returns nothing. -

    Prev Up Next
    Chapter 37. Numerics Home Chapter 39. Input and Output
    +

    Prev Up Next
    Chapter 24. Numerics Home Chapter 26. Input and Output
    diff --git a/libstdc++-v3/doc/html/manual/ext_numerics.html b/libstdc++-v3/doc/html/manual/ext_numerics.html index e8f86678a7c..3316ec1d0ea 100644 --- a/libstdc++-v3/doc/html/manual/ext_numerics.html +++ b/libstdc++-v3/doc/html/manual/ext_numerics.html @@ -1,9 +1,9 @@ -Chapter 37. Numerics
    Chapter 37. Numerics
    Prev Part XII.  +Chapter 24. Numerics
    Chapter 24. Numerics
    Prev Part III.  Extensions - Next

    Chapter 37. Numerics

    26.4, the generalized numeric operations such as accumulate, are extended +

    		 Next

    Chapter 24. Numerics

    26.4, the generalized numeric operations such as accumulate, are extended with the following functions: 

        power (x, n);
@@ -17,4 +17,4 @@
    That is, it assigns value to *first, value + 1 to *(first + 1) and so
    on."  Quoted from SGI documentation.
 
    -   void iota(_ForwardIter first, _ForwardIter last, _Tp value);
    Prev Up Next
    Chapter 36. Algorithms Home Chapter 38. Iterators
    + void iota(_ForwardIter first, _ForwardIter last, _Tp value);
    Prev Up Next
    Chapter 23. Algorithms Home Chapter 25. Iterators
    diff --git a/libstdc++-v3/doc/html/manual/ext_utilities.html b/libstdc++-v3/doc/html/manual/ext_utilities.html index 2685de374b9..3485222aa4b 100644 --- a/libstdc++-v3/doc/html/manual/ext_utilities.html +++ b/libstdc++-v3/doc/html/manual/ext_utilities.html @@ -1,19 +1,19 @@ -Chapter 35. Utilities
    Chapter 35. Utilities
    Prev Part XII.  +Chapter 22. Utilities
    Chapter 22. Utilities
    Prev Part III.  Extensions - Next

    Chapter 35. Utilities

    +

    		 Next

    Chapter 22. Utilities

    The <functional> header contains many additional functors and helper functions, extending section 20.3. They are implemented in the file stl_function.h: -

    • identity_element for addition and multiplication. * +

      • identity_element for addition and multiplication. *

      • The functor identity, whose operator() - returns the argument unchanged. * + returns the argument unchanged. *

      • Composition functors unary_function and binary_function, and their helpers compose1 - and compose2. * -

      • select1st and select2nd, to strip pairs. * + and compose2. * +

      • select1st and select2nd, to strip pairs. *

      • project1st and project2nd. *

      • A set of functors/functions which always return the same result. They are constant_void_fun, constant_binary_fun, constant_unary_fun, constant0, @@ -38,4 +38,4 @@ get_temporary_buffer(5, (int*)0);

        The specialized algorithms of section 20.4.4 are extended with uninitialized_copy_n. * -

      Prev Up Next
      Deprecated HP/SGI Home Chapter 36. Algorithms
      +

    Prev Up Next
    Deprecated HP/SGI Home Chapter 23. Algorithms
    diff --git a/libstdc++-v3/doc/html/manual/extensions.html b/libstdc++-v3/doc/html/manual/extensions.html index f441d4c8ad8..1046b4ba442 100644 --- a/libstdc++-v3/doc/html/manual/extensions.html +++ b/libstdc++-v3/doc/html/manual/extensions.html @@ -1,9 +1,9 @@ -Part XII.  Extensions
    Part XII.  +Part III.  Extensions
    Part III.  Extensions -
    Prev The GNU C++ Library Next

    Part XII.  +

    Prev The GNU C++ Library Next

    Part III.  Extensions - -

    Table of Contents

    29. Compile Time Checks
    30. Debug Mode
    Intro
    Semantics
    Using
    Using the Debug Mode
    Using a Specific Debug Container
    Design
    Goals
    Methods
    Other Implementations
    31. Parallel Mode
    Intro
    Semantics
    Using
    Prerequisite Compiler Flags
    Using Parallel Mode
    Using Specific Parallel Components
    Design
    Interface Basics
    Configuration and Tuning
    Implementation Namespaces
    Testing
    Bibliography
    32. Profile Mode
    Intro
    Using the Profile Mode
    Tuning the Profile Mode
    Design
    Wrapper Model
    Instrumentation
    Run Time Behavior
    Analysis and Diagnostics
    Cost Model
    Reports
    Testing
    Extensions for Custom Containers
    Empirical Cost Model
    Implementation Issues
    Stack Traces
    Symbolization of Instruction Addresses
    Concurrency
    Using the Standard Library in the Instrumentation Implementation
    Malloc Hooks
    Construction and Destruction of Global Objects
    Developer Information
    Big Picture
    How To Add A Diagnostic
    Diagnostics
    Diagnostic Template
    Containers
    Algorithms
    Data Locality
    Multithreaded Data Access
    Statistics
    Bibliography
    33. Allocators
    mt_allocator
    Intro
    Design Issues
    Implementation
    Single Thread Example
    Multiple Thread Example
    bitmap_allocator
    Design
    Implementation
    34. Containers
    Policy Based Data Structures
    HP/SGI
    Deprecated HP/SGI
    35. Utilities
    36. Algorithms
    37. Numerics
    38. Iterators
    39. Input and Output
    Derived filebufs
    40. Demangling
    41. Concurrency
    Design
    Interface to Locks and Mutexes
    Interface to Atomic Functions
    Implementation
    Using Builtin Atomic Functions
    Thread Abstraction
    Use
    Prev Up Next
    Performance Home 
    + +

    Table of Contents

    16. Compile Time Checks
    17. Debug Mode
    Intro
    Semantics
    Using
    Using the Debug Mode
    Using a Specific Debug Container
    Design
    Goals
    Methods
    Other Implementations
    18. Parallel Mode
    Intro
    Semantics
    Using
    Prerequisite Compiler Flags
    Using Parallel Mode
    Using Specific Parallel Components
    Design
    Interface Basics
    Configuration and Tuning
    Implementation Namespaces
    Testing
    Bibliography
    19. Profile Mode
    Intro
    Using the Profile Mode
    Tuning the Profile Mode
    Design
    Wrapper Model
    Instrumentation
    Run Time Behavior
    Analysis and Diagnostics
    Cost Model
    Reports
    Testing
    Extensions for Custom Containers
    Empirical Cost Model
    Implementation Issues
    Stack Traces
    Symbolization of Instruction Addresses
    Concurrency
    Using the Standard Library in the Instrumentation Implementation
    Malloc Hooks
    Construction and Destruction of Global Objects
    Developer Information
    Big Picture
    How To Add A Diagnostic
    Diagnostics
    Diagnostic Template
    Containers
    Algorithms
    Data Locality
    Multithreaded Data Access
    Statistics
    Bibliography
    20. Allocators
    mt_allocator
    Intro
    Design Issues
    Implementation
    Single Thread Example
    Multiple Thread Example
    bitmap_allocator
    Design
    Implementation
    21. Containers
    Policy Based Data Structures
    HP/SGI
    Deprecated HP/SGI
    22. Utilities
    23. Algorithms
    24. Numerics
    25. Iterators
    26. Input and Output
    Derived filebufs
    27. Demangling
    28. Concurrency
    Design
    Interface to Locks and Mutexes
    Interface to Atomic Functions
    Implementation
    Using Builtin Atomic Functions
    Thread Abstraction
    Use
    Prev Up Next
    Facets Home 
    diff --git a/libstdc++-v3/doc/html/manual/facets.html b/libstdc++-v3/doc/html/manual/facets.html index ba3728e93d1..3a8542aff28 100644 --- a/libstdc++-v3/doc/html/manual/facets.html +++ b/libstdc++-v3/doc/html/manual/facets.html @@ -1,9 +1,9 @@ -Chapter 15. Facets aka Categories
    Chapter 15. Facets aka Categories
    Prev Part VI.  +Facets
    Facets
    Prev Chapter 8.  Localization - Next

    Chapter 15. Facets aka Categories

    Table of Contents

    ctype
    Implementation
    Future
    codecvt
    Requirements
    Design
    Implementation
    Use
    Future
    messages
    Requirements
    Design
    Implementation
    Use
    Future

    ctype

    Implementation

    Specializations

    +

    		 Next

    Facets

    ctype

    Implementation

    Specializations

    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 @@ -28,50 +28,725 @@ to wchar_t and wcsrtombs for conversions between wchar_t and char.

    Neither of these two required specializations deals with Unicode characters. -

    Future

    • - How to deal with the global locale issue? -

    • +

    Future

    • + How to deal with the global locale issue? +

    • How to deal with different types than char, wchar_t?

    • - Overlap between codecvt/ctype: narrow/widen -

    • + Overlap between codecvt/ctype: narrow/widen +

    • Mask typedef in codecvt_base, argument types in codecvt. what - is know about this type? -

    • + is know about this type? +

    • Why mask* argument in codecvt?

    • Can this be made (more) generic? is there a simple way to straighten out the configure-time mess that is a by-product of - this class? -

    • + this class? +

    • Get the ctype<wchar_t>::mask stuff under control. Need to make some kind of static table, and not do lookup every time somebody hits the do_is... functions. Too bad we can't just - redefine mask for ctype<wchar_t> -

    • + redefine mask for ctype<wchar_t> +

    • Rename abstract base class. See if just smash-overriding is a better approach. Clarify, add sanity to naming. -

    Bibliography

    +

    Bibliography

    The GNU C Library - . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization.

    + . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization.

    Correspondence - . Ulrich Drepper. Copyright © 2002 .

    + . Ulrich Drepper. Copyright © 2002 .

    ISO/IEC 14882:1998 Programming languages - C++ - . Copyright © 1998 ISO.

    + . Copyright © 1998 ISO.

    ISO/IEC 9899:1999 Programming languages - C - . Copyright © 1999 ISO.

    - The Open Group Base Specifications, Issue 6 (IEEE Std. 1003.1-2004) - . Copyright © 1999 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. + . Copyright © 1999 ISO.

    + + The Open Group Base Specifications, Issue 6 (IEEE Std. 1003.1-2004) + + + . Copyright © 1999 + The Open Group/The Institute of Electrical and Electronics Engineers, Inc..

    + The C++ Programming Language, Special Edition + . Bjarne Stroustrup. Copyright © 2000 Addison Wesley, Inc.. Appendix D. + Addison Wesley + .

    + Standard C++ IOStreams and Locales + . + Advanced Programmer's Guide and Reference + . Angelika Langer. Klaus Kreft. Copyright © 2000 Addison Wesley Longman, Inc.. + Addison Wesley Longman + .

    codecvt

    +The standard class codecvt attempts to address conversions between +different character encoding schemes. In particular, the standard +attempts to detail conversions between the implementation-defined wide +characters (hereafter referred to as wchar_t) and the standard type +char that is so beloved in classic “C” (which can now be +referred to as narrow characters.) This document attempts to describe +how the GNU libstdc++ implementation deals with the conversion between +wide and narrow characters, and also presents a framework for dealing +with the huge number of other encodings that iconv can convert, +including Unicode and UTF8. Design issues and requirements are +addressed, and examples of correct usage for both the required +specializations for wide and narrow characters and the +implementation-provided extended functionality are given. +

    Requirements

    +Around page 425 of the C++ Standard, this charming heading comes into view: +

    +22.2.1.5 - Template class codecvt +

    +The text around the codecvt definition gives some clues: +

    + +-1- The class codecvt<internT,externT,stateT> is for use when +converting from one codeset to another, such as from wide characters +to multibyte characters, between wide character encodings such as +Unicode and EUC. + +

    +Hmm. So, in some unspecified way, Unicode encodings and +translations between other character sets should be handled by this +class. +

    + +-2- The stateT argument selects the pair of codesets being mapped between. + +

    +Ah ha! Another clue... +

    + +-3- The instantiations required in the Table ?? +(lib.locale.category), namely codecvt<wchar_t,char,mbstate_t> and +codecvt<char,char,mbstate_t>, convert the implementation-defined +native character set. codecvt<char,char,mbstate_t> implements a +degenerate conversion; it does not convert at +all. codecvt<wchar_t,char,mbstate_t> converts between the native +character sets for tiny and wide characters. Instantiations on +mbstate_t perform conversion between encodings known to the library +implementor. Other encodings can be converted by specializing on a +user-defined stateT type. The stateT object can contain any state that +is useful to communicate to or from the specialized do_convert member. + +

    +At this point, a couple points become clear: +

    +One: The standard clearly implies that attempts to add non-required +(yet useful and widely used) conversions need to do so through the +third template parameter, stateT.

    +Two: The required conversions, by specifying mbstate_t as the third +template parameter, imply an implementation strategy that is mostly +(or wholly) based on the underlying C library, and the functions +mcsrtombs and wcsrtombs in particular.

    Design

    wchar_t Size

    + The simple implementation detail of wchar_t's size seems to + repeatedly confound people. Many systems use a two byte, + unsigned integral type to represent wide characters, and use an + internal encoding of Unicode or UCS2. (See AIX, Microsoft NT, + Java, others.) Other systems, use a four byte, unsigned integral + type to represent wide characters, and use an internal encoding + of UCS4. (GNU/Linux systems using glibc, in particular.) The C + programming language (and thus C++) does not specify a specific + size for the type wchar_t. +

    + Thus, portable C++ code cannot assume a byte size (or endianness) either. +

    Support for Unicode

    + Probably the most frequently asked question about code conversion + is: "So dudes, what's the deal with Unicode strings?" + The dude part is optional, but apparently the usefulness of + Unicode strings is pretty widely appreciated. Sadly, this specific + encoding (And other useful encodings like UTF8, UCS4, ISO 8859-10, + etc etc etc) are not mentioned in the C++ standard. +

    + A couple of comments: +

    + The thought that all one needs to convert between two arbitrary + codesets is two types and some kind of state argument is + unfortunate. In particular, encodings may be stateless. The naming + of the third parameter as stateT is unfortunate, as what is really + needed is some kind of generalized type that accounts for the + issues that abstract encodings will need. The minimum information + that is required includes: +

    • + Identifiers for each of the codesets involved in the + conversion. For example, using the iconv family of functions + from the Single Unix Specification (what used to be called + X/Open) hosted on the GNU/Linux operating system allows + bi-directional mapping between far more than the following + tantalizing possibilities: +

      + (An edited list taken from `iconv --list` on a + Red Hat 6.2/Intel system: + 

      +8859_1, 8859_9, 10646-1:1993, 10646-1:1993/UCS4, ARABIC, ARABIC7,
+ASCII, EUC-CN, EUC-JP, EUC-KR, EUC-TW, GREEK-CCIcode, GREEK, GREEK7-OLD,
+GREEK7, GREEK8, HEBREW, ISO-8859-1, ISO-8859-2, ISO-8859-3,
+ISO-8859-4, ISO-8859-5, ISO-8859-6, ISO-8859-7, ISO-8859-8,
+ISO-8859-9, ISO-8859-10, ISO-8859-11, ISO-8859-13, ISO-8859-14,
+ISO-8859-15, ISO-10646, ISO-10646/UCS2, ISO-10646/UCS4,
+ISO-10646/UTF-8, ISO-10646/UTF8, SHIFT-JIS, SHIFT_JIS, UCS-2, UCS-4,
+UCS2, UCS4, UNICODE, UNICODEBIG, UNICODELIcodeLE, US-ASCII, US, UTF-8,
+UTF-16, UTF8, UTF16).
+

      +For iconv-based implementations, string literals for each of the +encodings (i.e. "UCS-2" and "UTF-8") are necessary, +although for other, +non-iconv implementations a table of enumerated values or some other +mechanism may be required. +

    • + Maximum length of the identifying string literal. +

    • + Some encodings require explicit endian-ness. As such, some kind + of endian marker or other byte-order marker will be necessary. See + "Footnotes for C/C++ developers" in Haible for more information on + UCS-2/Unicode endian issues. (Summary: big endian seems most likely, + however implementations, most notably Microsoft, vary.) +

    • + Types representing the conversion state, for conversions involving + the machinery in the "C" library, or the conversion descriptor, for + conversions using iconv (such as the type iconv_t.) Note that the + conversion descriptor encodes more information than a simple encoding + state type. +

    • + Conversion descriptors for both directions of encoding. (i.e., both + UCS-2 to UTF-8 and UTF-8 to UCS-2.) +

    • + Something to indicate if the conversion requested if valid. +

    • + Something to represent if the conversion descriptors are valid. +

    • + Some way to enforce strict type checking on the internal and + external types. As part of this, the size of the internal and + external types will need to be known. +

    Other Issues

    +In addition, multi-threaded and multi-locale environments also impact +the design and requirements for code conversions. In particular, they +affect the required specialization codecvt<wchar_t, char, mbstate_t> +when implemented using standard "C" functions. +

    +Three problems arise, one big, one of medium importance, and one small. +

    +First, the small: mcsrtombs and wcsrtombs may not be multithread-safe +on all systems required by the GNU tools. For GNU/Linux and glibc, +this is not an issue. +

    +Of medium concern, in the grand scope of things, is that the functions +used to implement this specialization work on null-terminated +strings. Buffers, especially file buffers, may not be null-terminated, +thus giving conversions that end prematurely or are otherwise +incorrect. Yikes! +

    +The last, and fundamental problem, is the assumption of a global +locale for all the "C" functions referenced above. For something like +C++ iostreams (where codecvt is explicitly used) the notion of +multiple locales is fundamental. In practice, most users may not run +into this limitation. However, as a quality of implementation issue, +the GNU C++ library would like to offer a solution that allows +multiple locales and or simultaneous usage with computationally +correct results. In short, libstdc++ is trying to offer, as an +option, a high-quality implementation, damn the additional complexity! +

    +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 +LC_CTYPE category implements. +

    Implementation

    +The two required specializations are implemented as follows: +

    + +codecvt<char, char, mbstate_t> + +

    +This is a degenerate (i.e., does nothing) specialization. Implementing +this was a piece of cake. +

    + +codecvt<char, wchar_t, mbstate_t> + +

    +This specialization, by specifying all the template parameters, pretty +much ties the hands of implementors. As such, the implementation is +straightforward, involving mcsrtombs for the conversions between char +to wchar_t and wcsrtombs for conversions between wchar_t and char. +

    +Neither of these two required specializations deals with Unicode +characters. As such, libstdc++ implements a partial specialization +of the codecvt class with and iconv wrapper class, encoding_state as the +third template parameter. +

    +This implementation should be standards conformant. First of all, the +standard explicitly points out that instantiations on the third +template parameter, stateT, are the proper way to implement +non-required conversions. Second of all, the standard says (in Chapter +17) that partial specializations of required classes are a-ok. Third +of all, the requirements for the stateT type elsewhere in the standard +(see 21.1.2 traits typedefs) only indicate that this type be copy +constructible. +

    +As such, the type encoding_state is defined as a non-templatized, POD +type to be used as the third type of a codecvt instantiation. This +type is just a wrapper class for iconv, and provides an easy interface +to iconv functionality. +

    +There are two constructors for encoding_state: +

    + +encoding_state() : __in_desc(0), __out_desc(0) + +

    +This default constructor sets the internal encoding to some default +(currently UCS4) and the external encoding to whatever is returned by +nl_langinfo(CODESET). +

    + +encoding_state(const char* __int, const char* __ext) + +

    +This constructor takes as parameters string literals that indicate the +desired internal and external encoding. There are no defaults for +either argument. +

    +One of the issues with iconv is that the string literals identifying +conversions are not standardized. Because of this, the thought of +mandating and or enforcing some set of pre-determined valid +identifiers seems iffy: thus, a more practical (and non-migraine +inducing) strategy was implemented: end-users can specify any string +(subject to a pre-determined length qualifier, currently 32 bytes) for +encodings. It is up to the user to make sure that these strings are +valid on the target system. +

    + +void +_M_init() + +

    +Strangely enough, this member function attempts to open conversion +descriptors for a given encoding_state object. If the conversion +descriptors are not valid, the conversion descriptors returned will +not be valid and the resulting calls to the codecvt conversion +functions will return error. +

    + +bool +_M_good() + +

    +Provides a way to see if the given encoding_state object has been +properly initialized. If the string literals describing the desired +internal and external encoding are not valid, initialization will +fail, and this will return false. If the internal and external +encodings are valid, but iconv_open could not allocate conversion +descriptors, this will also return false. Otherwise, the object is +ready to convert and will return true. +

    + +encoding_state(const encoding_state&) + +

    +As iconv allocates memory and sets up conversion descriptors, the copy +constructor can only copy the member data pertaining to the internal +and external code conversions, and not the conversion descriptors +themselves. +

    +Definitions for all the required codecvt member functions are provided +for this specialization, and usage of codecvt<internal character type, +external character type, encoding_state> is consistent with other +codecvt usage. +

    Use

    A conversions involving string literal.

    +  typedef codecvt_base::result                  result;
+  typedef unsigned short                        unicode_t;
+  typedef unicode_t                             int_type;
+  typedef char                                  ext_type;
+  typedef encoding_state                          state_type;
+  typedef codecvt<int_type, ext_type, state_type> unicode_codecvt;
+
+  const ext_type*       e_lit = "black pearl jasmine tea";
+  int                   size = strlen(e_lit);
+  int_type              i_lit_base[24] =
+  { 25088, 27648, 24832, 25344, 27392, 8192, 28672, 25856, 24832, 29184,
+    27648, 8192, 27136, 24832, 29440, 27904, 26880, 28160, 25856, 8192, 29696,
+    25856, 24832, 2560
+  };
+  const int_type*       i_lit = i_lit_base;
+  const ext_type*       efrom_next;
+  const int_type*       ifrom_next;
+  ext_type*             e_arr = new ext_type[size + 1];
+  ext_type*             eto_next;
+  int_type*             i_arr = new int_type[size + 1];
+  int_type*             ito_next;
+
+  // construct a locale object with the specialized facet.
+  locale                loc(locale::classic(), new unicode_codecvt);
+  // sanity check the constructed locale has the specialized facet.
+  VERIFY( has_facet<unicode_codecvt>(loc) );
+  const unicode_codecvt& cvt = use_facet<unicode_codecvt>(loc);
+  // convert between const char* and unicode strings
+  unicode_codecvt::state_type state01("UNICODE", "ISO_8859-1");
+  initialize_state(state01);
+  result r1 = cvt.in(state01, e_lit, e_lit + size, efrom_next,
+		     i_arr, i_arr + size, ito_next);
+  VERIFY( r1 == codecvt_base::ok );
+  VERIFY( !int_traits::compare(i_arr, i_lit, size) );
+  VERIFY( efrom_next == e_lit + size );
+  VERIFY( ito_next == i_arr + size );
+

    Future

    • + a. things that are sketchy, or remain unimplemented: + do_encoding, max_length and length member functions + are only weakly implemented. I have no idea how to do + this correctly, and in a generic manner. Nathan? +

    • + b. conversions involving std::string +

      • + how should operators != and == work for string of + different/same encoding? +

      • + what is equal? A byte by byte comparison or an + encoding then byte comparison? +

      • + conversions between narrow, wide, and unicode strings +

    • + c. conversions involving std::filebuf and std::ostream +

      • + how to initialize the state object in a + standards-conformant manner? +

      • + how to synchronize the "C" and "C++" + conversion information? +

      • + wchar_t/char internal buffers and conversions between + internal/external buffers? +

    Bibliography

    + The GNU C Library + . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. + Chapters 6 Character Set Handling and 7 Locales and Internationalization + .

    + Correspondence + . Ulrich Drepper. Copyright © 2002 .

    + ISO/IEC 14882:1998 Programming languages - C++ + . Copyright © 1998 ISO.

    + ISO/IEC 9899:1999 Programming languages - C + . Copyright © 1999 ISO.

    + + + System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) + + + . Copyright © 2008 + The Open Group/The Institute of Electrical and Electronics + Engineers, Inc. + .

    + The C++ Programming Language, Special Edition + . Bjarne Stroustrup. Copyright © 2000 Addison Wesley, Inc.. Appendix D. + Addison Wesley + .

    + Standard C++ IOStreams and Locales + . + Advanced Programmer's Guide and Reference + . Angelika Langer. Klaus Kreft. Copyright © 2000 Addison Wesley Longman, Inc.. + Addison Wesley Longman + .

    + + + A brief description of Normative Addendum 1 + - .

    + . Clive Feather. Extended Character Sets.

    + + + The Unicode HOWTO + + + . Bruno Haible.

    + + + UTF-8 and Unicode FAQ for Unix/Linux + + + . Markus Khun.

    messages

    +The std::messages facet implements message retrieval functionality +equivalent to Java's java.text.MessageFormat .using either GNU gettext +or IEEE 1003.1-200 functions. +

    Requirements

    +The std::messages facet is probably the most vaguely defined facet in +the standard library. It's assumed that this facility was built into +the standard library in order to convert string literals from one +locale to the other. For instance, converting the "C" locale's +const char* c = "please" to a German-localized "bitte" +during program execution. +

    +22.2.7.1 - Template class messages [lib.locale.messages] +

    +This class has three public member functions, which directly +correspond to three protected virtual member functions. +

    +The public member functions are: +

    +catalog open(const string&, const locale&) const +

    +string_type get(catalog, int, int, const string_type&) const +

    +void close(catalog) const +

    +While the virtual functions are: +

    +catalog do_open(const string&, const locale&) const +

    + +-1- Returns: A value that may be passed to get() to retrieve a +message, from the message catalog identified by the string name +according to an implementation-defined mapping. The result can be used +until it is passed to close(). Returns a value less than 0 if no such +catalog can be opened. + +

    +string_type do_get(catalog, int, int, const string_type&) const +

    + +-3- Requires: A catalog cat obtained from open() and not yet closed. +-4- Returns: A message identified by arguments set, msgid, and dfault, +according to an implementation-defined mapping. If no such message can +be found, returns dfault. + +

    +void do_close(catalog) const +

    + +-5- Requires: A catalog cat obtained from open() and not yet closed. +-6- Effects: Releases unspecified resources associated with cat. +-7- Notes: The limit on such resources, if any, is implementation-defined. + +

    Design

    +A couple of notes on the standard. +

    +First, why is messages_base::catalog specified as a typedef +to int? This makes sense for implementations that use +catopen, but not for others. Fortunately, it's not heavily +used and so only a minor irritant. +

    +Second, by making the member functions const, it is +impossible to save state in them. Thus, storing away information used +in the 'open' member function for use in 'get' is impossible. This is +unfortunate. +

    +The 'open' member function in particular seems to be oddly +designed. The signature seems quite peculiar. Why specify a const +string& argument, for instance, instead of just const +char*? Or, why specify a const locale& argument that is +to be used in the 'get' member function? How, exactly, is this locale +argument useful? What was the intent? It might make sense if a locale +argument was associated with a given default message string in the +'open' member function, for instance. Quite murky and unclear, on +reflection. +

    +Lastly, it seems odd that messages, which explicitly require code +conversion, don't use the codecvt facet. Because the messages facet +has only one template parameter, it is assumed that ctype, and not +codecvt, is to be used to convert between character sets. +

    +It is implicitly assumed that the locale for the default message +string in 'get' is in the "C" locale. Thus, all source code is assumed +to be written in English, so translations are always from "en_US" to +other, explicitly named locales. +

    Implementation

    Models

    + This is a relatively simple class, on the face of it. The standard + specifies very little in concrete terms, so generic + implementations that are conforming yet do very little are the + norm. Adding functionality that would be useful to programmers and + comparable to Java's java.text.MessageFormat takes a bit of work, + and is highly dependent on the capabilities of the underlying + operating system. +

    + Three different mechanisms have been provided, selectable via + configure flags: +

    • + generic +

      + This model does very little, and is what is used by default. +

    • + gnu +

      + The gnu model is complete and fully tested. It's based on the + GNU gettext package, which is part of glibc. It uses the + functions textdomain, bindtextdomain, gettext to + implement full functionality. Creating message catalogs is a + relatively straight-forward process and is lightly documented + below, and fully documented in gettext's distributed + documentation. +

    • + ieee_1003.1-200x +

      + This is a complete, though untested, implementation based on + the IEEE standard. The functions catopen, catgets, + catclose are used to retrieve locale-specific messages + given the appropriate message catalogs that have been + constructed for their use. Note, the script + po2msg.sed that is part of the gettext distribution can + convert gettext catalogs into catalogs that + catopen can use. +

    +A new, standards-conformant non-virtual member function signature was +added for 'open' so that a directory could be specified with a given +message catalog. This simplifies calling conventions for the gnu +model. +

    The GNU Model

    + The messages facet, because it is retrieving and converting + between characters sets, depends on the ctype and perhaps the + codecvt facet in a given locale. In addition, underlying "C" + library locale support is necessary for more than just the + LC_MESSAGES mask: LC_CTYPE is also + necessary. To avoid any unpleasantness, all bits of the "C" mask + (i.e. LC_ALL) are set before retrieving messages. +

    + Making the message catalogs can be initially tricky, but become + quite simple with practice. For complete info, see the gettext + documentation. Here's an idea of what is required: +

    • + Make a source file with the required string literals that need + to be translated. See intl/string_literals.cc for + an example. +

    • + Make initial catalog (see "4 Making the PO Template File" from + the gettext docs).

      + xgettext --c++ --debug string_literals.cc -o libstdc++.pot +

    • Make language and country-specific locale catalogs.

      + cp libstdc++.pot fr_FR.po +

      + cp libstdc++.pot de_DE.po +

    • + Edit localized catalogs in emacs so that strings are + translated. +

      + emacs fr_FR.po +

    • Make the binary mo files.

      + msgfmt fr_FR.po -o fr_FR.mo +

      + msgfmt de_DE.po -o de_DE.mo +

    • Copy the binary files into the correct directory structure.

      + cp fr_FR.mo (dir)/fr_FR/LC_MESSAGES/libstdc++.mo +

      + cp de_DE.mo (dir)/de_DE/LC_MESSAGES/libstdc++.mo +

    • Use the new message catalogs.

      + locale loc_de("de_DE"); +

      + + use_facet<messages<char> >(loc_de).open("libstdc++", locale(), dir); + +

    Use

    + A simple example using the GNU model of message conversion. + 

    +#include <iostream>
+#include <locale>
+using namespace std;
+
+void test01()
+{
+  typedef messages<char>::catalog catalog;
+  const char* dir =
+  "/mnt/egcs/build/i686-pc-linux-gnu/libstdc++/po/share/locale";
+  const locale loc_de("de_DE");
+  const messages<char>& mssg_de = use_facet<messages<char> >(loc_de);
+
+  catalog cat_de = mssg_de.open("libstdc++", loc_de, dir);
+  string s01 = mssg_de.get(cat_de, 0, 0, "please");
+  string s02 = mssg_de.get(cat_de, 0, 0, "thank you");
+  cout << "please in german:" << s01 << '\n';
+  cout << "thank you in german:" << s02 << '\n';
+  mssg_de.close(cat_de);
+}
+

    Future

    • + Things that are sketchy, or remain unimplemented: +

      • + _M_convert_from_char, _M_convert_to_char are in flux, + depending on how the library ends up doing character set + conversions. It might not be possible to do a real character + set based conversion, due to the fact that the template + parameter for messages is not enough to instantiate the + codecvt facet (1 supplied, need at least 2 but would prefer + 3). +

      • + There are issues with gettext needing the global locale set + to extract a message. This dependence on the global locale + makes the current "gnu" model non MT-safe. Future versions + of glibc, i.e. glibc 2.3.x will fix this, and the C++ library + bits are already in place. +

    • + Development versions of the GNU "C" library, glibc 2.3 will allow + a more efficient, MT implementation of std::messages, and will + allow the removal of the _M_name_messages data member. If this is + done, it will change the library ABI. The C++ parts to support + glibc 2.3 have already been coded, but are not in use: once this + version of the "C" library is released, the marked parts of the + messages implementation can be switched over to the new "C" + library functionality. +

    • + At some point in the near future, std::numpunct will probably use + std::messages facilities to implement truename/falsename + correctly. This is currently not done, but entries in + libstdc++.pot have already been made for "true" and "false" string + literals, so all that remains is the std::numpunct coding and the + configure/make hassles to make the installed library search its + own catalog. Currently the libstdc++.mo catalog is only searched + for the testsuite cases involving messages members. +

    • The following member functions:

      + + catalog + open(const basic_string<char>& __s, const locale& __loc) const + +

      + + catalog + open(const basic_string<char>&, const locale&, const char*) const; + +

      + Don't actually return a "value less than 0 if no such catalog + can be opened" as required by the standard in the "gnu" + model. As of this writing, it is unknown how to query to see + if a specified message catalog exists using the gettext + package. +

    Bibliography

    + The GNU C Library + . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. Chapters 6 Character Set Handling, and 7 Locales and Internationalization + .

    + Correspondence + . Ulrich Drepper. Copyright © 2002 .

    + ISO/IEC 14882:1998 Programming languages - C++ + . Copyright © 1998 ISO.

    + ISO/IEC 9899:1999 Programming languages - C + . Copyright © 1999 ISO.

    + + + System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) + + + . Copyright © 2008 + The Open Group/The Institute of Electrical and Electronics + Engineers, Inc. + .

    The C++ Programming Language, Special Edition . Bjarne Stroustrup. Copyright © 2000 Addison Wesley, Inc.. Appendix D. Addison Wesley - .

    + .

    Standard C++ IOStreams and Locales . Advanced Programmer's Guide and Reference . Angelika Langer. Klaus Kreft. Copyright © 2000 Addison Wesley Longman, Inc.. Addison Wesley Longman - .

    Prev Up Next
    Chapter 14. Locales Home codecvt
    + .

    + + + API Specifications, Java Platform + + + . java.util.Properties, java.text.MessageFormat, +java.util.Locale, java.util.ResourceBundle + .

    + + + GNU gettext tools, version 0.10.38, Native Language Support +Library and Tools. + + + .

    Prev Up Next
    Chapter 8.  + Localization + + Home Chapter 9.  + Containers + +
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt11ch27s02.html b/libstdc++-v3/doc/html/manual/fstreams.html similarity index 52% rename from libstdc++-v3/doc/html/manual/bk01pt11ch27s02.html rename to libstdc++-v3/doc/html/manual/fstreams.html index 4366e8fd8c0..0795443b26d 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt11ch27s02.html +++ b/libstdc++-v3/doc/html/manual/fstreams.html @@ -1,6 +1,55 @@ -Binary Input and Output
    Binary Input and Output
    Prev Chapter 27. File Based Streams Next

    Binary Input and Output

    +File Based Streams

    File Based Streams
    Prev Chapter 13.  + Input and Output + + Next

    File Based Streams

    Copying a File

    +

    So you want to copy a file quickly and easily, and most important, + completely portably. And since this is C++, you have an open + ifstream (call it IN) and an open ofstream (call it OUT): + 

    +   #include <fstream>
+
+   std::ifstream  IN ("input_file");
+   std::ofstream  OUT ("output_file");

    Here's the easiest way to get it completely wrong: + 

    +   OUT << IN;

    For those of you who don't already know why this doesn't work + (probably from having done it before), I invite you to quickly + create a simple text file called "input_file" containing + the sentence + 

    +      The quick brown fox jumped over the lazy dog.

    surrounded by blank lines. Code it up and try it. The contents + of "output_file" may surprise you. +

    Seriously, go do it. Get surprised, then come back. It's worth it. +

    The thing to remember is that the basic_[io]stream classes + handle formatting, nothing else. In chaptericular, they break up on + whitespace. The actual reading, writing, and storing of data is + handled by the basic_streambuf family. Fortunately, the + operator<< is overloaded to take an ostream and + a pointer-to-streambuf, in order to help with just this kind of + "dump the data verbatim" situation. +

    Why a pointer to streambuf and not just a streambuf? Well, + the [io]streams hold pointers (or references, depending on the + implementation) to their buffers, not the actual + buffers. This allows polymorphic behavior on the chapter of the buffers + as well as the streams themselves. The pointer is easily retrieved + using the rdbuf() member function. Therefore, the easiest + way to copy the file is: + 

    +   OUT << IN.rdbuf();

    So what was happening with OUT<<IN? Undefined + behavior, since that chaptericular << isn't defined by the Standard. + I have seen instances where it is implemented, but the character + extraction process removes all the whitespace, leaving you with no + blank lines and only "Thequickbrownfox...". With + libraries that do not define that operator, IN (or one of IN's + member pointers) sometimes gets converted to a void*, and the output + file then contains a perfect text representation of a hexadecimal + address (quite a big surprise). Others don't compile at all. +

    Also note that none of this is specific to o*f*streams. + The operators shown above are all defined in the parent + basic_ostream class and are therefore available with all possible + descendants. +

    Binary Input and Output

    The first and most important thing to remember about binary I/O is that opening a file with ios::binary is not, repeat not, the only thing you have to do. It is not a silver @@ -21,11 +70,11 @@ under Windows won't accidentally get mapped to a '\n' character, etc. Binary mode is not supposed to suddenly give you a bitstream, and if it is doing so in your program then you've discovered a bug in - your vendor's compiler (or some other part of the C++ implementation, + your vendor's compiler (or some other chapter of the C++ implementation, possibly the runtime system).

    Second, using << to write and >> to read isn't going to work with the standard file stream classes, even - if you use skipws during reading. Why not? Because + if you use skipws during reading. Why not? Because ifstream and ofstream exist for the purpose of formatting, not reading and writing. Their job is to interpret the data into text characters, and that's exactly what you don't want to happen @@ -39,13 +88,13 @@ which requires that formatting not be done? There are a seemingly infinite number of solutions, and a few are listed here:

    • “Derive your own fstream-type classes and write your own - <</>> operators to do binary I/O on whatever data - types you're using.” + <</>> operators to do binary I/O on whatever data + types you're using.”

      This is a Bad Thing, because while - the compiler would probably be just fine with it, other humans - are going to be confused. The overloaded bitshift operators - have a well-defined meaning (formatting), and this breaks it. + the compiler would probably be just fine with it, other humans + are going to be confused. The overloaded bitshift operators + have a well-defined meaning (formatting), and this breaks it.

    • “Build the file structure in memory, then mmap() the file and copy the @@ -59,10 +108,10 @@

    • “Use streambufs, that's what they're there for.”

      - While not trivial for the beginner, this is the best of all - solutions. The streambuf/filebuf layer is the layer that is - responsible for actual I/O. If you want to use the C++ - library for binary I/O, this is where you start. + While not trivial for the beginner, this is the best of all + solutions. The streambuf/filebuf layer is the layer that is + responsible for actual I/O. If you want to use the C++ + library for binary I/O, this is where you start.

    How to go about using streambufs is a bit beyond the scope of this document (at least for now), but while streambufs go a long way, they still leave a couple of things up to you, the programmer. @@ -84,7 +133,7 @@ variables of type int_type.)

    Another area of problems is opening text files in binary mode. Generally, binary mode is intended for binary files, and opening - text files in binary mode means that you now have to deal with all of + text files in binary mode means that you now have to deal with all of those end-of-line and end-of-file problems that we mentioned before.

    An instructive thread from comp.lang.c++.moderated delved off into @@ -98,4 +147,4 @@ between arbitrary programs, or across a network, or from one invocation of a program to another invocation of the same program on a different platform, etc. -

    Prev Up Next
    Chapter 27. File Based Streams Home Chapter 28. Interacting with C
    +

    Prev Up Next
    Memory Based Streams Home Interacting with C
    diff --git a/libstdc++-v3/doc/html/manual/functors.html b/libstdc++-v3/doc/html/manual/functors.html deleted file mode 100644 index eca77856530..00000000000 --- a/libstdc++-v3/doc/html/manual/functors.html +++ /dev/null @@ -1,15 +0,0 @@ - - -Chapter 9. Functors
    Chapter 9. Functors
    Prev Part IV.  - Utilities - - Next

    Chapter 9. Functors

    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 - their - http://www.sgi.com/tech/stl/functors.html. -

    Prev Up Next
    Part IV.  - Utilities - - Home Chapter 10. Pairs
    diff --git a/libstdc++-v3/doc/html/manual/fundamental_types.html b/libstdc++-v3/doc/html/manual/fundamental_types.html deleted file mode 100644 index 0196e5a8dec..00000000000 --- a/libstdc++-v3/doc/html/manual/fundamental_types.html +++ /dev/null @@ -1,43 +0,0 @@ - - -Chapter 4. Types
    Chapter 4. Types
    Prev Part II.  - Support - - Next

    Chapter 4. Types

    Table of Contents

    Fundamental Types
    Numeric Properties
    NULL

    Fundamental Types

    - C++ has the following builtin types: -

    • - char -

    • - signed char -

    • - unsigned char -

    • - signed short -

    • - signed int -

    • - signed long -

    • - unsigned short -

    • - unsigned int -

    • - unsigned long -

    • - bool -

    • - wchar_t -

    • - float -

    • - double -

    • - long double -

    - These fundamental types are always available, without having to - include a header file. These types are exactly the same in - either C++ or in C. -

    - Specializing parts of the library on these types is prohibited: - instead, use a POD. -

    Prev Up Next
     Home Numeric Properties
    diff --git a/libstdc++-v3/doc/html/manual/generalized_numeric_operations.html b/libstdc++-v3/doc/html/manual/generalized_numeric_operations.html index 74e54b47d44..7047824afa3 100644 --- a/libstdc++-v3/doc/html/manual/generalized_numeric_operations.html +++ b/libstdc++-v3/doc/html/manual/generalized_numeric_operations.html @@ -1,15 +1,15 @@ -Chapter 22. Generalized Operations
    Chapter 22. Generalized Operations
    Prev Part X.  +Generalized Operations
    Generalized Operations
    Prev Chapter 12.  Numerics - Next

    Chapter 22. Generalized Operations

    +

    		 Next

    Generalized Operations

    There are four generalized functions in the <numeric> header that follow the same conventions as those in <algorithm>. Each of them is overloaded: one signature for common default operations, and a second for fully general operations. Their names are self-explanatory to anyone who works with numerics on a regular basis: -

    • accumulate

    • inner_product

    • partial_sum

    • adjacent_difference

    Here is a simple example of the two forms of accumulate. +

    • accumulate

    • inner_product

    • chapterial_sum

    • adjacent_difference

    Here is a simple example of the two forms of accumulate. 

        int   ar[50];
    int   someval = somefunction();
@@ -26,4 +26,7 @@
       and multiplies all the members of the array; here we must obviously
       use 1 as a starting value instead of 0.
    
    The other three functions have similar dual-signature forms.
-
    Prev Up Next
    Chapter 21. Complex Home Chapter 23. Interacting with C
    +

    Prev Up Next
    Chapter 12.  + Numerics + + Home Interacting with C
    diff --git a/libstdc++-v3/doc/html/manual/internals.html b/libstdc++-v3/doc/html/manual/internals.html index cc6df8ba72c..1512752fa74 100644 --- a/libstdc++-v3/doc/html/manual/internals.html +++ b/libstdc++-v3/doc/html/manual/internals.html @@ -41,7 +41,7 @@ in sparc-sun-solaris2.8. If the new directory is name OS portion of the triplet (the default), then nothing needs to be changed.

    The first file to create in this directory, should be called os_defines.h. This file contains basic macro definitions -that are required to allow the C++ library to work with your C library. +that are required to allow the C++ library to work with your C library.

    Several libstdc++ source files unconditionally define the macro _POSIX_SOURCE. On many systems, defining this macro causes large portions of the C library header files to be eliminated @@ -91,7 +91,7 @@ are exposing proper support for the related set of functions. If defined, it must be 0 while bootstrapping the compiler/rebuilding the library.

    Finally, you should bracket the entire file in an include-guard, like this: - 

         
+   
     
 #ifndef _GLIBCXX_OS_DEFINES
 #define _GLIBCXX_OS_DEFINES
@@ -131,7 +131,7 @@ upper-case, lower-case, alphabetic, etc.  The ctype_base.h<ctype.h> to figure out
 how to define the values required by this file.
-   
    The ctype_base.h header file does not need include guards. 
+   
    The ctype_base.h header file does not need include guards.
 It should contain a single struct definition called
 ctype_base.  This struct should contain two type
 declarations, and one enumeration declaration, like this example, taken
@@ -141,20 +141,20 @@ from the IRIX configuration:
      {
        typedef unsigned int 	mask;
        typedef int* 		__to_type;
-     
+
        enum
        {
-         space = _ISspace,
-         print = _ISprint,
-         cntrl = _IScntrl,
-         upper = _ISupper,
-         lower = _ISlower,
-         alpha = _ISalpha,
-         digit = _ISdigit,
-         punct = _ISpunct,
-         xdigit = _ISxdigit,
-         alnum = _ISalnum,
-         graph = _ISgraph
+	 space = _ISspace,
+	 print = _ISprint,
+	 cntrl = _IScntrl,
+	 upper = _ISupper,
+	 lower = _ISlower,
+	 alpha = _ISalpha,
+	 digit = _ISdigit,
+	 punct = _ISpunct,
+	 xdigit = _ISxdigit,
+	 alnum = _ISalnum,
+	 graph = _ISgraph
        };
      };
 
    The mask type is the type of the elements in the table.  If your
@@ -176,14 +176,14 @@ function that must be written is the ctype<char>::ctype
 constructor.  Here is the IRIX example:
    
     ctype<char>::ctype(const mask* __table = 0, bool __del = false,
-           size_t __refs = 0)
+	   size_t __refs = 0)
        : _Ctype_nois<char>(__refs), _M_del(__table != 0 && __del),
-         _M_toupper(NULL),
-         _M_tolower(NULL),
-         _M_ctable(NULL),
-         _M_table(!__table
-                  ? (const mask*) (__libc_attr._ctype_tbl->_class + 1)
-                  : __table)
+	 _M_toupper(NULL),
+	 _M_tolower(NULL),
+	 _M_ctable(NULL),
+	 _M_table(!__table
+		  ? (const mask*) (__libc_attr._ctype_tbl->_class + 1)
+		  : __table)
        { }
 
    There are two parts of this that you might choose to alter. The first,
 and most important, is the line involving __libc_attr.  That is
@@ -199,7 +199,7 @@ lower-case, and vice versa.  Here are the IRIX versions:
      char
      ctype<char>::do_toupper(char __c) const
      { return _toupper(__c); }
-     
+
      char
      ctype<char>::do_tolower(char __c) const
      { return _tolower(__c); }
@@ -215,21 +215,21 @@ machinery to do that on your system:
      ctype<char>::do_toupper(char* __low, const char* __high) const
      {
        while (__low < __high)
-         {
-           *__low = do_toupper(*__low);
-           ++__low;
-         }
+	 {
+	   *__low = do_toupper(*__low);
+	   ++__low;
+	 }
        return __high;
      }
-     
+
      const char*
      ctype<char>::do_tolower(char* __low, const char* __high) const
      {
        while (__low < __high)
-         {
-           *__low = do_tolower(*__low);
-           ++__low;
-         }
+	 {
+	   *__low = do_tolower(*__low);
+	   ++__low;
+	 }
        return __high;
      }

    You must also provide the ctype_inline.h file, which @@ -244,7 +244,7 @@ properties; they are analogous to the functions like isalpha< ctype<char>:: is(mask __m, char __c) const throw() { return (_M_table)[(unsigned char)(__c)] & __m; } -

    The _M_table is the table passed in above, in the constructor. +

    The _M_table is the table passed in above, in the constructor. This is the table that contains the bitmasks for each character. The implementation here should work on all systems.

    The next function is: @@ -254,7 +254,7 @@ implementation here should work on all systems. is(const char* __low, const char* __high, mask* __vec) const throw() { while (__low < __high) - *__vec++ = (_M_table)[(unsigned char)(*__low++)]; + *__vec++ = (_M_table)[(unsigned char)(*__low++)]; return __high; }

    This function is similar; it copies the masks for all the characters @@ -267,16 +267,16 @@ from __low up until __high i scan_is(mask __m, const char* __low, const char* __high) const throw() { while (__low < __high && !this->is(__m, *__low)) - ++__low; + ++__low; return __low; } - + const char* ctype<char>:: scan_not(mask __m, const char* __low, const char* __high) const throw() { while (__low < __high && this->is(__m, *__low)) - ++__low; + ++__low; return __low; }

    Thread Safety

    The C++ library string functionality requires a couple of atomic @@ -312,7 +312,7 @@ type, and two functions.

    The type is _Atomic_word. Here is the version used on IRIX: 

     typedef long _Atomic_word;
-

    This type must be a signed integral type supporting atomic operations. +

    This type must be a signed integral type supporting atomic operations. If you're using the OS approach, use the same type used by your system's primitives. Otherwise, use the type for which your CPU provides atomic primitives. @@ -327,7 +327,7 @@ must be equivalent to those provided here, but using atomic operations: *__mem += __val; return __result; } - + static inline void __attribute__ ((__unused__)) __atomic_add (_Atomic_word* __mem, int __val) @@ -335,18 +335,18 @@ must be equivalent to those provided here, but using atomic operations: *__mem += __val; }

    Numeric Limits

    The C++ library requires information about the fundamental data types, -such as the minimum and maximum representable values of each type. +such as the minimum and maximum representable values of each type. You can define each of these values individually, but it is usually easiest just to indicate how many bits are used in each of the data types and let the library do the rest. For information about the macros to define, see the top of include/bits/std_limits.h. -

    If you need to define any macros, you can do so in os_defines.h. +

    If you need to define any macros, you can do so in os_defines.h. However, if all operating systems for your CPU are likely to use the same values, you can provide a CPU-specific file instead so that you -do not have to provide the same definitions for each operating system. +do not have to provide the same definitions for each operating system. To take that approach, create a new file called cpu_limits.h in your CPU configuration directory (see CPU). -

    Libtool

    The C++ library is compiled, archived and linked with libtool. +

    Libtool

    The C++ library is compiled, archived and linked with libtool. Explaining the full workings of libtool is beyond the scope of this document, but there are a few, particular bits that are necessary for porting. diff --git a/libstdc++-v3/doc/html/manual/intro.html b/libstdc++-v3/doc/html/manual/intro.html index 690722ffdf9..15091ef0834 100644 --- a/libstdc++-v3/doc/html/manual/intro.html +++ b/libstdc++-v3/doc/html/manual/intro.html @@ -5,5 +5,5 @@

    Prev The GNU C++ Library Next

    Part I.  Introduction - +

    Table of Contents

    1. Status
    Implementation Status
    C++ 1998/2003
    C++ 200x
    C++ TR1
    C++ TR 24733
    License
    The Code: GPL
    The Documentation: GPL, FDL
    Bugs
    Implementation Bugs
    Standard Bugs
    2. Setup
    Prerequisites
    Configure
    Make
    3. Using
    Command Options
    Headers
    Header Files
    Mixing Headers
    The C Headers and namespace std
    Precompiled Headers
    Macros
    Namespaces
    Available Namespaces
    namespace std
    Using Namespace Composition
    Linking
    Almost Nothing
    Finding Dynamic or Shared Libraries
    Concurrency
    Prerequisites
    Thread Safety
    Atomics
    IO
    Containers
    Exceptions
    Exception Safety
    Exception Neutrality
    Doing without
    Compatibility
    Debugging Support
    Using g++
    Debug Versions of Library Binary Files
    Memory Leak Hunting
    Using gdb
    Tracking uncaught exceptions
    Debug Mode
    Compile Time Checking
    Profile-based Performance Analysis
    Prev Up Next
    The GNU C++ Library Home Chapter 1. Status
    diff --git a/libstdc++-v3/doc/html/manual/iostream_objects.html b/libstdc++-v3/doc/html/manual/io.html similarity index 66% rename from libstdc++-v3/doc/html/manual/iostream_objects.html rename to libstdc++-v3/doc/html/manual/io.html index 1133edec3ab..65f598db241 100644 --- a/libstdc++-v3/doc/html/manual/iostream_objects.html +++ b/libstdc++-v3/doc/html/manual/io.html @@ -1,9 +1,14 @@ -Chapter 24. Iostream Objects
    Chapter 24. Iostream Objects
    Prev Part XI.  +Chapter 13.  Input and Output
    Chapter 13.  Input and Output - Next

    Chapter 24. Iostream Objects

    To minimize the time you have to wait on the compiler, it's good to +

    Prev Part II.  + Standard Contents + Next

    Chapter 13.  + Input and Output + +

    Table of Contents

    Iostream Objects
    Stream Buffers
    Derived streambuf Classes
    Buffering
    Memory Based Streams
    Compatibility With strstream
    File Based Streams
    Copying a File
    Binary Input and Output
    Interacting with C
    Using FILE* and file descriptors
    Performance

    Iostream Objects

    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 penalize your runtime as well. Here are some tips on which header to use @@ -20,8 +25,8 @@ class MyClass { - .... - std::ifstream& input_file; + .... + std::ifstream& input_file; }; extern std::ostream& operator<< (std::ostream&, MyClass&); @@ -78,18 +83,18 @@ namespace std { - extern istream cin; - extern ostream cout; - .... + extern istream cin; + extern ostream cout; + .... - // this is explained below - static ios_base::Init __foo; // not its real name + // this is explained below + static ios_base::Init __foo; // not its real name }

    Now, the runtime penalty mentioned previously: the global objects must be initialized before any of your own code uses them; this is guaranteed by the standard. Like any other global object, they must be initialized once and only once. This is typically done with a - construct like the one above, and the nested class ios_base::Init is + construct like the one above, and the nested class ios_base::Init is specified in the standard for just this reason.

    How does it work? Because the header is included before any of your code, the __foo object is constructed before any of @@ -113,7 +118,4 @@ the standard objects in that source file; you'll pay less startup time. Only include the header files you need to in general; your compile times will go down when there's less parsing work to do. -

    Prev Up Next
    Part XI.  - Input and Output - - Home Chapter 25. Stream Buffers
    +

    Prev Up Next
    Interacting with C Home Stream Buffers
    diff --git a/libstdc++-v3/doc/html/manual/bk01pt11ch28s02.html b/libstdc++-v3/doc/html/manual/io_and_c.html similarity index 53% rename from libstdc++-v3/doc/html/manual/bk01pt11ch28s02.html rename to libstdc++-v3/doc/html/manual/io_and_c.html index 69fa0f12ec1..f7a99e6ada0 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt11ch28s02.html +++ b/libstdc++-v3/doc/html/manual/io_and_c.html @@ -1,6 +1,14 @@ -Performance
    Performance
    Prev Chapter 28. Interacting with C Next

    Performance

    +Interacting with C

    Interacting with C
    Prev Chapter 13.  + Input and Output + + Next

    Interacting with C

    Using FILE* and file descriptors

    + See the extensions for using + FILE and file descriptors with + ofstream and + ifstream. +

    Performance

    Pathetic Performance? Ditch C.

    It sounds like a flame on C, but it isn't. Really. Calm down. I'm just saying it to get your attention. @@ -40,10 +48,10 @@

    Note, by the way, that the synchronization requirement only applies to the standard streams (cin, cout, cerr, - clog, and their wide-character counterparts). File stream + clog, and their wide-character counterchapters). File stream objects that you declare yourself have no such requirement and are fully buffered. -

    Prev Up Next
    Chapter 28. Interacting with C Home Part XII.  - Extensions +

    Prev Up Next
    File Based Streams Home Chapter 14.  + Atomics
    diff --git a/libstdc++-v3/doc/html/manual/iterators.html b/libstdc++-v3/doc/html/manual/iterators.html dissimilarity index 85% index d9a932be228..6e29f5fcc94 100644 --- a/libstdc++-v3/doc/html/manual/iterators.html +++ b/libstdc++-v3/doc/html/manual/iterators.html @@ -1,9 +1,130 @@ - - -Part VIII.  Iterators
    Part VIII.  - Iterators - -
    Prev The GNU C++ Library Next

    Part VIII.  - Iterators - -

    Table of Contents

    19. Predefined
    Iterators vs. Pointers
    One Past the End
    Prev Up Next
    bitset Home Chapter 19. Predefined
    + + +Chapter 10.  Iterators
    Chapter 10.  + Iterators + +
    Prev Part II.  + Standard Contents + Next

    Chapter 10.  + Iterators + +

    Table of Contents

    Predefined
    Iterators vs. Pointers
    One Past the End

    Predefined

    Iterators vs. Pointers

    + The following +FAQ entry points out that +iterators are not implemented as pointers. They are a generalization +of pointers, but they are implemented in libstdc++ as separate +classes. +

    + Keeping that simple fact in mind as you design your code will + prevent a whole lot of difficult-to-understand bugs. +

    + You can think of it the other way 'round, even. Since iterators + are a generalization, that means + that pointers are + iterators, and that pointers can be used + whenever an iterator would be. All those functions in the + Algorithms sect1 of the Standard will work just as well on plain + arrays and their pointers. +

    + That doesn't mean that when you pass in a pointer, it gets + wrapped into some special delegating iterator-to-pointer class + with a layer of overhead. (If you think that's the case + anywhere, you don't understand templates to begin with...) Oh, + no; if you pass in a pointer, then the compiler will instantiate + that template using T* as a type, and good old high-speed + pointer arithmetic as its operations, so the resulting code will + be doing exactly the same things as it would be doing if you had + hand-coded it yourself (for the 273rd time). +

    + How much overhead is there when using an + iterator class? Very little. Most of the layering classes + contain nothing but typedefs, and typedefs are + "meta-information" that simply tell the compiler some + nicknames; they don't create code. That information gets passed + down through inheritance, so while the compiler has to do work + looking up all the names, your runtime code does not. (This has + been a prime concern from the beginning.) +

    One Past the End

    This starts off sounding complicated, but is actually very easy, + especially towards the end. Trust me. +

    Beginners usually have a little trouble understand the whole + 'past-the-end' thing, until they remember their early algebra classes + (see, they told you that stuff would come in handy!) and + the concept of half-open ranges. +

    First, some history, and a reminder of some of the funkier rules in + C and C++ for builtin arrays. The following rules have always been + true for both languages: +

    1. You can point anywhere in the array, or to the first element + past the end of the array. A pointer that points to one + past the end of the array is guaranteed to be as unique as a + pointer to somewhere inside the array, so that you can compare + such pointers safely. +

    2. You can only dereference a pointer that points into an array. + If your array pointer points outside the array -- even to just + one past the end -- and you dereference it, Bad Things happen. +

    3. Strictly speaking, simply pointing anywhere else invokes + undefined behavior. Most programs won't puke until such a + pointer is actually dereferenced, but the standards leave that + up to the platform. +

    The reason this past-the-end addressing was allowed is to make it + easy to write a loop to go over an entire array, e.g., + while (*d++ = *s++);. +

    So, when you think of two pointers delimiting an array, don't think + of them as indexing 0 through n-1. Think of them as boundary + markers: + 

    +
+   beginning            end
+     |                   |
+     |                   |               This is bad.  Always having to
+     |                   |               remember to add or subtract one.
+     |                   |               Off-by-one bugs very common here.
+     V                   V
+	array of N elements
+     |---|---|--...--|---|---|
+     | 0 | 1 |  ...  |N-2|N-1|
+     |---|---|--...--|---|---|
+
+     ^                       ^
+     |                       |
+     |                       |           This is good.  This is safe.  This
+     |                       |           is guaranteed to work.  Just don't
+     |                       |           dereference 'end'.
+   beginning                end
+
+

    See? Everything between the boundary markers is chapter of the array. + Simple. +

    Now think back to your junior-high school algebra course, when you + were learning how to draw graphs. Remember that a graph terminating + with a solid dot meant, "Everything up through this point," + and a graph terminating with an open dot meant, "Everything up + to, but not including, this point," respectively called closed + and open ranges? Remember how closed ranges were written with + brackets, [a,b], and open ranges were written with parentheses, + (a,b)? +

    The boundary markers for arrays describe a half-open range, + starting with (and including) the first element, and ending with (but + not including) the last element: [beginning,end). See, I + told you it would be simple in the end. +

    Iterators, and everything working with iterators, follows this same + time-honored tradition. A container's begin() method returns + an iterator referring to the first element, and its end() + method returns a past-the-end iterator, which is guaranteed to be + unique and comparable against any other iterator pointing into the + middle of the container. +

    Container constructors, container methods, and algorithms, all take + pairs of iterators describing a range of values on which to operate. + All of these ranges are half-open ranges, so you pass the beginning + iterator as the starting parameter, and the one-past-the-end iterator + as the finishing parameter. +

    This generalizes very well. You can operate on sub-ranges quite + easily this way; functions accepting a [first,last) range + don't know or care whether they are the boundaries of an entire {array, + sequence, container, whatever}, or whether they only enclose a few + elements from the center. This approach also makes zero-length + sequences very simple to recognize: if the two endpoints compare + equal, then the {array, sequence, container, whatever} is empty. +

    Just don't dereference end(). +

    Prev Up Next
    Interacting with C Home Chapter 11.  + Algorithms + +
    diff --git a/libstdc++-v3/doc/html/manual/license.html b/libstdc++-v3/doc/html/manual/license.html index f660ff378a0..04c971a059b 100644 --- a/libstdc++-v3/doc/html/manual/license.html +++ b/libstdc++-v3/doc/html/manual/license.html @@ -2,7 +2,7 @@ License
    License
    Prev Chapter 1. Status Next

    License

    There are two licenses affecting GNU libstdc++: one for the code, - and one for the documentation. + and one for the documentation.

    There is a license section in the FAQ regarding common questions. If you have more questions, ask the FSF or the gcc mailing list. @@ -94,7 +94,7 @@ requirements of the license of GCC.
    GNU Free Documentation License version 1.2. There are no Front-Cover Texts, no Back-Cover Texts, and no Invariant Sections. -

    +

    For documentation generated by doxygen or other automated tools via processing source code comments and markup, the original source code license applies to the generated files. Thus, the doxygen diff --git a/libstdc++-v3/doc/html/manual/locales.html b/libstdc++-v3/doc/html/manual/localization.html similarity index 65% rename from libstdc++-v3/doc/html/manual/locales.html rename to libstdc++-v3/doc/html/manual/localization.html index 040f79f2103..a1f30163645 100644 --- a/libstdc++-v3/doc/html/manual/locales.html +++ b/libstdc++-v3/doc/html/manual/localization.html @@ -1,13 +1,18 @@ -Chapter 14. Locales

    Chapter 14. Locales
    Prev Part VI.  +Chapter 8.  Localization
    Chapter 8.  Localization - Next

    Chapter 14. Locales

    Table of Contents

    locale
    Requirements
    Design
    Implementation
    Future

    locale

    +

    Prev Part II.  + Standard Contents + Next

    Chapter 8.  + Localization + +

    Table of Contents

    Locales
    locale
    Facets
    ctype
    codecvt
    messages

    Locales

    locale

    Describes the basic locale object, including nested classes id, facet, and the reference-counted implementation object, class _Impl. -

    Requirements

    +

    Requirements

    Class locale is non-templatized and has two distinct types nested inside of it:

    @@ -43,15 +48,15 @@ class id

    Provides an index for looking up specific facets. -

    Design

    +

    Design

    The major design challenge is fitting an object-orientated and non-global locale design on top of POSIX and other relevant standards, which include the Single Unix (nee X/Open.)

    Because C and earlier versions of POSIX fall down so completely, portability is an issue. -

    Implementation

    Interacting with "C" locales

    • - `locale -a` displays available locales. +

    Implementation

    Interacting with "C" locales

    • + `locale -a` displays available locales. 

       af_ZA
 ar_AE
@@ -351,7 +356,7 @@ zh_HK.utf8
 zh_TW
 zh_TW.euctw
 zh_TW.utf8
-

    • +

  • `locale` displays environmental variables that impact how locale("") will be deduced. 

    @@ -380,49 +385,55 @@ global locale" (emphasis Paolo), that is:
   particular on the working of locale(""), which constructs the locale
   object from the environment of the running program, that is, in
   practice, the set of LC_ALL, LANG, etc. variable of the shell.
-

    • Future

    • +

    Future

    • Locale initialization: at what point does _S_classic, _S_global get initialized? Can named locales assume this initialization - has already taken place? -

    • + has already taken place? +

    • Document how named locales error check when filling data members. I.e., a fr_FR locale that doesn't have numpunct::truename(): does it use "true"? Or is it a blank - string? What's the convention? -

    • + string? What's the convention? +

    • Explain how locale aliasing happens. When does "de_DE" use "de" information? What is the rule for locales composed of just an ISO language code (say, "de") and locales with both an ISO - language code and ISO country code (say, "de_DE"). -

    • + language code and ISO country code (say, "de_DE"). +

    • What should non-required facet instantiations do? If the generic implementation is provided, then how to end-users - provide specializations? -

    Bibliography

    + provide specializations? +

    Bibliography

    The GNU C Library - . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. Chapters 6 Character Set Handling and 7 Locales and Internationalization.

    + . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. + Chapters 6 Character Set Handling and 7 Locales and + Internationalization + .

    Correspondence - . Ulrich Drepper. Copyright © 2002 .

    + . Ulrich Drepper. Copyright © 2002 .

    ISO/IEC 14882:1998 Programming languages - C++ - . Copyright © 1998 ISO.

    + . Copyright © 1998 ISO.

    ISO/IEC 9899:1999 Programming languages - C - . Copyright © 1999 ISO.

    - The Open Group Base Specifications, Issue 6 (IEEE Std. 1003.1-2004) - . Copyright © 1999 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. - + . Copyright © 1999 ISO.

    + + + System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) + - .

    + . Copyright © 2008 + The Open Group/The Institute of Electrical and Electronics + Engineers, Inc. + .

    The C++ Programming Language, Special Edition . Bjarne Stroustrup. Copyright © 2000 Addison Wesley, Inc.. Appendix D. Addison Wesley - .

    + .

    Standard C++ IOStreams and Locales . Advanced Programmer's Guide and Reference . Angelika Langer. Klaus Kreft. Copyright © 2000 Addison Wesley Longman, Inc.. Addison Wesley Longman - .

    Prev Up Next
    Part VI.  - Localization + .

    Prev Up Next
    Chapter 7.  + Strings - Home Chapter 15. Facets aka Categories
    +     		Home Facets
    diff --git a/libstdc++-v3/doc/html/manual/memory.html b/libstdc++-v3/doc/html/manual/memory.html index 18db2d502bf..82ef8c7125f 100644 --- a/libstdc++-v3/doc/html/manual/memory.html +++ b/libstdc++-v3/doc/html/manual/memory.html @@ -1,15 +1,15 @@ -Chapter 11. Memory
    Chapter 11. Memory
    Prev Part IV.  +Memory
    Memory
    Prev Chapter 6.  Utilities - Next

    Chapter 11. Memory

    Table of Contents

    Allocators
    Requirements
    Design Issues
    Implementation
    Using a Specific Allocator
    Custom Allocators
    Extension Allocators
    auto_ptr
    Limitations
    Use in Containers
    shared_ptr
    Requirements
    Design Issues
    Implementation
    Use
    Acknowledgments

    +

    		 Next

    Memory

    Memory contains three general areas. First, function and operator calls via new and delete operator or member function calls. Second, allocation via allocator. And finally, smart pointer and intelligent pointer abstractions. -

    Allocators

    +

    Allocators

    Memory management for Standard Library entities is encapsulated in a class template called allocator. The allocator abstraction is used throughout the @@ -17,7 +17,7 @@ algorithms, and parts of iostreams. This class, and base classes of it, are the superset of available free store (“heap”) management classes. -

    Requirements

    +

    Requirements

    The C++ standard only gives a few directives in this area:

    • When you add elements to a container, and the container must @@ -32,9 +32,9 @@ container-of-T is allocator<T>.

    • The interface of the allocator<T> class is - extremely simple. It has about 20 public declarations (nested - typedefs, member functions, etc), but the two which concern us most - are: + extremely simple. It has about 20 public declarations (nested + typedefs, member functions, etc), but the two which concern us most + are: 

       	 T*    allocate   (size_type n, const void* hint = 0);
 	 void  deallocate (T* p, size_type n);
@@ -43,18 +43,18 @@
 	 functions is a count of the number of
 	 T's to allocate space for, not their
 	 total size.
-	 (This is a simplification; the real signatures use nested typedefs.)  
+	 (This is a simplification; the real signatures use nested typedefs.)

    • The storage is obtained by calling ::operator new, but it is unspecified when or how - often this function is called. The use of the + often this function is called. The use of the hint is unspecified, but intended as an aid to locality if an implementation so desires. [20.4.1.1]/6 -

    +

    Complete details can be found in the C++ standard, look in [20.4 Memory]. -

    Design Issues

    +

    Design Issues

    The easiest way of fulfilling the requirements is to call operator new each time a container needs memory, and to call operator delete each time @@ -67,7 +67,7 @@ while __gnu_cxx::malloc_allocator implements much the same thing, only with the C language functions std::malloc and free. -

    +

    Another approach is to use intelligence within the allocator class to cache allocations. This extra machinery can take a variety of forms: a bitmap index, an index into an exponentially increasing @@ -93,33 +93,33 @@ or loading and unloading shared objects in memory. As such, using caching allocators on systems that do not support abi::__cxa_atexit is not recommended. -

    Implementation

    Interface Design

    +

    Implementation

    Interface Design

    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 - been modified to support this change. -

    + been modified to support this change. +

    The class allocator just has typedef, constructor, and rebind members. It inherits from one of the high-speed extension allocators, covered below. Thus, all allocation and deallocation depends on the base class. -

    +

    The base class that allocator is derived from may not be user-configurable. -

    Selecting Default Allocation Policy

    +

    Selecting Default Allocation Policy

    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 for speed. -

    +

    Three synthetic benchmarks have been created that provide data that is used to compare different C++ allocators. These tests are:

    1. - Insertion. + Insertion.

      Over multiple iterations, various STL container objects have elements inserted to some maximum amount. A variety - of allocators are tested. + of allocators are tested. Test source for sequence and associative containers. @@ -128,22 +128,22 @@

      This test shows the ability of the allocator to reclaim memory on a per-thread basis, as well as measuring thread contention - for memory resources. - Test source + for memory resources. + Test source here.

    2. A threaded producer/consumer model.

      Test source for sequence - and + and associative containers.

    The current default choice for allocator is __gnu_cxx::new_allocator. -

    Disabling Memory Caching

    +

    Disabling Memory Caching

    In use, allocator may allocate and deallocate using implementation-specified strategies and heuristics. Because of this, every call to an allocator object's @@ -151,13 +151,13 @@ call the global operator new. This situation is also duplicated for calls to the deallocate member function. -

    - This can be confusing. -

    +

    + This can be confusing. +

    In particular, this can make debugging memory errors more difficult, especially when using third party tools like valgrind or debug versions of new. -

    +

    There are various ways to solve this problem. One would be to use a custom allocator that just called operators new and delete @@ -179,7 +179,7 @@ environment, it likely means that you linked against objects built against the older library (objects which might still using the cached allocations...). -

    Using a Specific Allocator

    +

    Using a Specific Allocator

    You can specify different memory management schemes on a per-container basis, by overriding the default Allocator template parameter. For example, an easy @@ -190,16 +190,16 @@ Likewise, a debugging form of whichever allocator is currently in use: 

         std::deque <int, __gnu_cxx::debug_allocator<std::allocator<int> > >  debug_deque;
-

    Custom Allocators

    +

    Custom Allocators

    Writing a portable C++ allocator would dictate that the interface would look much like the one specified for allocator. Additional member functions, but not subtractions, would be permissible. -

    +

    Probably the best place to start would be to copy one of the - extension allocators: say a simple one like + extension allocators: say a simple one like new_allocator. -

    Extension Allocators

    +

    Extension Allocators

    Several other allocators are provided as part of this implementation. The location of the extension allocators and their names have changed, but in all cases, functionality is @@ -237,7 +237,7 @@ startup. For usage examples, please consult the testsuite.

  • debug_allocator -

    +

    A wrapper around an arbitrary allocator A. It passes on slightly increased size requests to A, and uses the extra memory to store size information. When a pointer is passed @@ -246,13 +246,13 @@ guarantee they match.

  • throw_allocator -

    +

    Includes memory tracking and marking abilities as well as hooks for throwing exceptions at configurable intervals (including random, - all, none). + all, none).

  • __pool_alloc -

    +

    A high-performance, single pool allocator. The reusable memory is shared among identical instantiations of this type. It calls through ::operator new to @@ -261,7 +261,7 @@ size, then the pool is bypassed, and the allocate/deallocate request is passed to ::operator new directly. -

    +

    Older versions of this class take a boolean template parameter, called thr, and an integer template parameter, called inst. @@ -308,39 +308,422 @@ A high-performance allocator that uses a bit-map to keep track of the used and unused memory locations. It has its own documentation, found here. -

    • Bibliography

    - ISO/IEC 14882:1998 Programming languages - C++ +

    Bibliography

    + ISO/IEC 14882:1998 Programming languages - C++ . isoc++_1998 - 20.4 Memory.

    The Standard Librarian: What Are Allocators Good - . - austernm - Matt Austern. - C/C++ Users Journal - . - + 20.4 Memory.

    + + + The Standard Librarian: What Are Allocators Good For? + - .

    The Hoard Memory Allocator. - emeryb - Emery Berger. + . Matt Austern. + C/C++ Users Journal + .

    + + The Hoard Memory Allocator + - .

    Reconsidering Custom Memory Allocation. - bergerzorn - Emery Berger. Ben Zorn. Kathryn McKinley. Copyright © 2002 OOPSLA. + . Emery Berger.

    + + Reconsidering Custom Memory Allocation + - .

    Allocator Types. - kreftlanger - Klaus Kreft. Angelika Langer. - C/C++ Users Journal - . + . Emery Berger. Ben Zorn. Kathryn McKinley. Copyright © 2002 OOPSLA.

    + + Allocator Types + - .

    The C++ Programming Language. - tcpl - Bjarne Stroustrup. Copyright © 2000 . 19.4 Allocators. + . Klaus Kreft. Angelika Langer. + C/C++ Users Journal + .

    The C++ Programming Language. Bjarne Stroustrup. Copyright © 2000 . 19.4 Allocators. Addison Wesley - .

    Yalloc: A Recycling C++ Allocator. - yenf - Felix Yen. Copyright © .

    Prev Up Next
    Chapter 10. Pairs Home auto_ptr
    + .

    Yalloc: A Recycling C++ Allocator. Felix Yen.

    auto_ptr

    Limitations

    Explaining all of the fun and delicious things that can + happen with misuse of the auto_ptr class + template (called AP here) would take some + time. Suffice it to say that the use of AP + safely in the presence of copying has some subtleties. +

    + The AP class is a really + nifty idea for a smart pointer, but it is one of the dumbest of + all the smart pointers -- and that's fine. +

    + AP is not meant to be a supersmart solution to all resource + leaks everywhere. Neither is it meant to be an effective form + of garbage collection (although it can help, a little bit). + And it can notbe used for arrays! +

    + AP is meant to prevent nasty leaks in the + presence of exceptions. That's all. This + code is AP-friendly: + 

    +    // Not a recommend naming scheme, but good for web-based FAQs.
+    typedef std::auto_ptr<MyClass>  APMC;
+
+    extern function_taking_MyClass_pointer (MyClass*);
+    extern some_throwable_function ();
+
+    void func (int data)
+    {
+	APMC  ap (new MyClass(data));
+
+	some_throwable_function();   // this will throw an exception
+
+	function_taking_MyClass_pointer (ap.get());
+    }
+

    When an exception gets thrown, the instance of MyClass that's + been created on the heap will be delete'd as the stack is + unwound past func(). +

    Changing that code as follows is not AP-friendly: + 

    +	APMC  ap (new MyClass[22]);
+

    You will get the same problems as you would without the use + of AP: + 

    +	char*  array = new char[10];       // array new...
+	...
+	delete array;                      // ...but single-object delete
+

    + AP cannot tell whether the pointer you've passed at creation points + to one or many things. If it points to many things, you are about + to die. AP is trivial to write, however, so you could write your + own auto_array_ptr for that situation (in fact, this has + been done many times; check the mailing lists, Usenet, Boost, etc). +

    Use in Containers

    +

    All of the containers + described in the standard library require their contained types + to have, among other things, a copy constructor like this: + 

    +    struct My_Type
+    {
+	My_Type (My_Type const&);
+    };
+

    + Note the const keyword; the object being copied shouldn't change. + The template class auto_ptr (called AP here) does not + meet this requirement. Creating a new AP by copying an existing + one transfers ownership of the pointed-to object, which means that + the AP being copied must change, which in turn means that the + copy ctors of AP do not take const objects. +

    + The resulting rule is simple: Never ever use a + container of auto_ptr objects. The standard says that + “undefined” behavior is the result, but it is + guaranteed to be messy. +

    + To prevent you from doing this to yourself, the + concept checks built + in to this implementation will issue an error if you try to + compile code like this: + 

    +    #include <vector>
+    #include <memory>
+
+    void f()
+    {
+	std::vector< std::auto_ptr<int> >   vec_ap_int;
+    }
+

    +Should you try this with the checks enabled, you will see an error. +

    shared_ptr

    +The shared_ptr class template stores a pointer, usually obtained via new, +and implements shared ownership semantics. +

    Requirements

    +

    + The standard deliberately doesn't require a reference-counted + implementation, allowing other techniques such as a + circular-linked-list. +

    + At the time of writing the C++0x working paper doesn't mention how + threads affect shared_ptr, but it is likely to follow the existing + practice set by boost::shared_ptr. The + shared_ptr in libstdc++ is derived from Boost's, so the same rules + apply. +

    +

    Design Issues

    +The shared_ptr code is kindly donated to GCC by the Boost +project and the original authors of the code. The basic design and +algorithms are from Boost, the notes below describe details specific to +the GCC implementation. Names have been uglified in this implementation, +but the design should be recognisable to anyone familiar with the Boost +1.32 shared_ptr. +

    +The basic design is an abstract base class, _Sp_counted_base that +does the reference-counting and calls virtual functions when the count +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. +

    Implementation

    Class Hierarchy

    +A shared_ptr<T> contains a pointer of +type T* and an object of type +__shared_count. The shared_count contains a +pointer of type _Sp_counted_base* which points to the +object that maintains the reference-counts and destroys the managed +resource. +

    _Sp_counted_base<Lp>

    +The base of the hierarchy is parameterized on the lock policy alone. +_Sp_counted_base doesn't depend on the type of pointer being managed, +it only maintains the reference counts and calls virtual functions when +the counts drop to zero. The managed object is destroyed when the last +strong reference is dropped, but the _Sp_counted_base itself must exist +until the last weak reference is dropped. +

    _Sp_counted_base_impl<Ptr, Deleter, Lp>

    +Inherits from _Sp_counted_base and stores a pointer of type Ptr +and a deleter of type Deleter. _Sp_deleter is +used when the user doesn't supply a custom deleter. Unlike Boost's, this +default deleter is not "checked" because GCC already issues a warning if +delete is used with an incomplete type. +This is the only derived type used by shared_ptr<Ptr> +and it is never used by shared_ptr, which uses one of +the following types, depending on how the shared_ptr is constructed. +

    _Sp_counted_ptr<Ptr, Lp>

    +Inherits from _Sp_counted_base and stores a pointer of type Ptr, +which is passed to delete when the last reference is dropped. +This is the simplest form and is used when there is no custom deleter or +allocator. +

    _Sp_counted_deleter<Ptr, Deleter, Alloc>

    +Inherits from _Sp_counted_ptr and adds support for custom deleter and +allocator. Empty Base Optimization is used for the allocator. This class +is used even when the user only provides a custom deleter, in which case +allocator is used as the allocator. +

    _Sp_counted_ptr_inplace<Tp, Alloc, Lp>

    +Used by allocate_shared and make_shared. +Contains aligned storage to hold an object of type Tp, +which is constructed in-place with placement new. +Has a variadic template constructor allowing any number of arguments to +be forwarded to Tp's constructor. +Unlike the other _Sp_counted_* classes, this one is parameterized on the +type of object, not the type of pointer; this is purely a convenience +that simplifies the implementation slightly. +

    Thread Safety

    +The interface of tr1::shared_ptr was extended for C++0x +with support for rvalue-references and the other features from +N2351. As with other libstdc++ headers shared by TR1 and C++0x, +boost_shared_ptr.h uses conditional compilation, based on the macros +_GLIBCXX_INCLUDE_AS_CXX0X and +_GLIBCXX_INCLUDE_AS_TR1, to enable and disable +features. +

    +C++0x-only features are: rvalue-ref/move support, allocator support, +aliasing constructor, make_shared & allocate_shared. Additionally, +the constructors taking auto_ptr parameters are +deprecated in C++0x mode. +

    +The +Thread +Safety section of the Boost shared_ptr documentation says "shared_ptr +objects offer the same level of thread safety as built-in types." +The implementation must ensure that concurrent updates to separate shared_ptr +instances are correct even when those instances share a reference count e.g. +

    +shared_ptr<A> a(new A);
+shared_ptr<A> b(a);
+
+// Thread 1     // Thread 2
+   a.reset();      b.reset();
+

    +The dynamically-allocated object must be destroyed by exactly one of the +threads. Weak references make things even more interesting. +The shared state used to implement shared_ptr must be transparent to the +user and invariants must be preserved at all times. +The key pieces of shared state are the strong and weak reference counts. +Updates to these need to be atomic and visible to all threads to ensure +correct cleanup of the managed resource (which is, after all, shared_ptr's +job!) +On multi-processor systems memory synchronisation may be needed so that +reference-count updates and the destruction of the managed resource are +race-free. +

    +The function _Sp_counted_base::_M_add_ref_lock(), called when +obtaining a shared_ptr from a weak_ptr, has to test if the managed +resource still exists and either increment the reference count or throw +bad_weak_ptr. +In a multi-threaded program there is a potential race condition if the last +reference is dropped (and the managed resource destroyed) between testing +the reference count and incrementing it, which could result in a shared_ptr +pointing to invalid memory. +

    +The Boost shared_ptr (as used in GCC) features a clever lock-free +algorithm to avoid the race condition, but this relies on the +processor supporting an atomic Compare-And-Swap +instruction. For other platforms there are fall-backs using mutex +locks. Boost (as of version 1.35) includes several different +implementations and the preprocessor selects one based on the +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. +

    Selecting Lock Policy

    +

    +There is a single _Sp_counted_base class, +which is a template parameterized on the enum +__gnu_cxx::_Lock_policy. The entire family of classes is +parameterized on the lock policy, right up to +__shared_ptr, __weak_ptr and +__enable_shared_from_this. The actual +std::shared_ptr class inherits from +__shared_ptr with the lock policy parameter +selected automatically based on the thread model and platform that +libstdc++ is configured for, so that the best available template +specialization will be used. This design is necessary because it would +not be conforming for shared_ptr to have an +extra template parameter, even if it had a default value. The +available policies are: +

    1. + _S_Atomic +

      +Selected when GCC supports a builtin atomic compare-and-swap operation +on the target processor (see Atomic +Builtins.) The reference counts are maintained using a lock-free +algorithm and GCC's atomic builtins, which provide the required memory +synchronisation. +

    2. + _S_Mutex +

      +The _Sp_counted_base specialization for this policy contains a mutex, +which is locked in add_ref_lock(). This policy is used when GCC's atomic +builtins aren't available so explicit memory barriers are needed in places. +

    3. + _S_Single +

      +This policy uses a non-reentrant add_ref_lock() with no locking. It is +used when libstdc++ is built without --enable-threads. +

    + For all three policies, reference count increments and + decrements are done via the functions in + ext/atomicity.h, 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. +

    Dual C++0x and TR1 Implementation

    +The classes derived from _Sp_counted_base (see Class Hierarchy +below) and __shared_count are implemented separately for C++0x +and TR1, in bits/boost_sp_shared_count.h and +tr1/boost_sp_shared_count.h respectively. All other classes +including _Sp_counted_base are shared by both implementations. +

    +The TR1 implementation is considered relatively stable, so is unlikely to +change unless bug fixes require it. If the code that is common to both +C++0x and TR1 modes needs to diverge further then it might be necessary to +duplicate additional classes and only make changes to the C++0x versions. +

    Related functions and classes
    dynamic_pointer_cast, static_pointer_cast, +const_pointer_cast

    +As noted in N2351, these functions can be implemented non-intrusively using +the alias constructor. However the aliasing constructor is only available +in C++0x mode, so in TR1 mode these casts rely on three non-standard +constructors in shared_ptr and __shared_ptr. +In C++0x mode these constructors and the related tag types are not needed. +

    enable_shared_from_this

    +The clever overload to detect a base class of type +enable_shared_from_this comes straight from Boost. +There is an extra overload for __enable_shared_from_this to +work smoothly with __shared_ptr<Tp, Lp> using any lock +policy. +

    make_shared, allocate_shared

    +make_shared simply forwards to allocate_shared +with std::allocator as the allocator. +Although these functions can be implemented non-intrusively using the +alias constructor, if they have access to the implementation then it is +possible to save storage and reduce the number of heap allocations. The +newly constructed object and the _Sp_counted_* can be allocated in a single +block and the standard says implementations are "encouraged, but not required," +to do so. This implementation provides additional non-standard constructors +(selected with the type _Sp_make_shared_tag) which create an +object of type _Sp_counted_ptr_inplace to hold the new object. +The returned shared_ptr<A> needs to know the address of the +new A object embedded in the _Sp_counted_ptr_inplace, +but it has no way to access it. +This implementation uses a "covert channel" to return the address of the +embedded object when get_deleter<_Sp_make_shared_tag>() +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. +

    Use

    Examples

    + Examples of use can be found in the testsuite, under + testsuite/tr1/2_general_utilities/shared_ptr. +

    Unresolved Issues

    + The resolution to C++ Standard Library issue 674, + "shared_ptr interface changes for consistency with N1856" will + need to be implemented after it is accepted into the working + paper. Issue 743 + might also require changes. +

    + The _S_single policy uses atomics when used in MT + code, because it uses the same dispatcher functions that check + __gthread_active_p(). This could be + addressed by providing template specialisations for some members + of _Sp_counted_base<_S_single>. +

    + Unlike Boost, this implementation does not use separate classes + for the pointer+deleter and pointer+deleter+allocator cases in + C++0x mode, combining both into _Sp_counted_deleter and using + allocator when the user doesn't specify + an allocator. If it was found to be beneficial an additional + class could easily be added. With the current implementation, + the _Sp_counted_deleter and __shared_count constructors taking a + custom deleter but no allocator are technically redundant and + could be removed, changing callers to always specify an + allocator. If a separate pointer+deleter class was added the + __shared_count constructor would be needed, so it has been kept + for now. +

    + The hack used to get the address of the managed object from + _Sp_counted_ptr_inplace::_M_get_deleter() + is accessible to users. This could be prevented if + get_deleter<_Sp_make_shared_tag>() + always returned NULL, since the hack only needs to work at a + lower level, not in the public API. This wouldn't be difficult, + but hasn't been done since there is no danger of accidental + misuse: users already know they are relying on unsupported + features if they refer to implementation details such as + _Sp_make_shared_tag. +

    + tr1::_Sp_deleter could be a private member of tr1::__shared_count but it + would alter the ABI. +

    + Exposing the alias constructor in TR1 mode could simplify the + *_pointer_cast functions. Constructor could be private in TR1 + mode, with the cast functions as friends. +

    Acknowledgments

    + The original authors of the Boost shared_ptr, which is really nice + 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. +

    Bibliography

    + + + Improving shared_ptr for C++0x, Revision 2 + + + . + N2351 + .

    + + + C++ Standard Library Active Issues List + + + . + N2456 + .

    + + + Working Draft, Standard for Programming Language C++ + + + . + N2461 + .

    + shared_ptr + + Boost C++ Libraries documentation, shared_ptr + + + . + N2461 + .

    Prev Up Next
    Pairs Home Traits
    diff --git a/libstdc++-v3/doc/html/manual/messages.html b/libstdc++-v3/doc/html/manual/messages.html deleted file mode 100644 index bd663dbf742..00000000000 --- a/libstdc++-v3/doc/html/manual/messages.html +++ /dev/null @@ -1,284 +0,0 @@ - - -messages
    messages
    Prev Chapter 15. Facets aka Categories Next

    messages

    -The std::messages facet implements message retrieval functionality -equivalent to Java's java.text.MessageFormat .using either GNU gettext -or IEEE 1003.1-200 functions. -

    Requirements

    -The std::messages facet is probably the most vaguely defined facet in -the standard library. It's assumed that this facility was built into -the standard library in order to convert string literals from one -locale to the other. For instance, converting the "C" locale's -const char* c = "please" to a German-localized "bitte" -during program execution. -

    -22.2.7.1 - Template class messages [lib.locale.messages] -

    -This class has three public member functions, which directly -correspond to three protected virtual member functions. -

    -The public member functions are: -

    -catalog open(const string&, const locale&) const -

    -string_type get(catalog, int, int, const string_type&) const -

    -void close(catalog) const -

    -While the virtual functions are: -

    -catalog do_open(const string&, const locale&) const -

    - --1- Returns: A value that may be passed to get() to retrieve a -message, from the message catalog identified by the string name -according to an implementation-defined mapping. The result can be used -until it is passed to close(). Returns a value less than 0 if no such -catalog can be opened. - -

    -string_type do_get(catalog, int, int, const string_type&) const -

    - --3- Requires: A catalog cat obtained from open() and not yet closed. --4- Returns: A message identified by arguments set, msgid, and dfault, -according to an implementation-defined mapping. If no such message can -be found, returns dfault. - -

    -void do_close(catalog) const -

    - --5- Requires: A catalog cat obtained from open() and not yet closed. --6- Effects: Releases unspecified resources associated with cat. --7- Notes: The limit on such resources, if any, is implementation-defined. - -

    Design

    -A couple of notes on the standard. -

    -First, why is messages_base::catalog specified as a typedef -to int? This makes sense for implementations that use -catopen, but not for others. Fortunately, it's not heavily -used and so only a minor irritant. -

    -Second, by making the member functions const, it is -impossible to save state in them. Thus, storing away information used -in the 'open' member function for use in 'get' is impossible. This is -unfortunate. -

    -The 'open' member function in particular seems to be oddly -designed. The signature seems quite peculiar. Why specify a const -string& argument, for instance, instead of just const -char*? Or, why specify a const locale& argument that is -to be used in the 'get' member function? How, exactly, is this locale -argument useful? What was the intent? It might make sense if a locale -argument was associated with a given default message string in the -'open' member function, for instance. Quite murky and unclear, on -reflection. -

    -Lastly, it seems odd that messages, which explicitly require code -conversion, don't use the codecvt facet. Because the messages facet -has only one template parameter, it is assumed that ctype, and not -codecvt, is to be used to convert between character sets. -

    -It is implicitly assumed that the locale for the default message -string in 'get' is in the "C" locale. Thus, all source code is assumed -to be written in English, so translations are always from "en_US" to -other, explicitly named locales. -

    Implementation

    Models

    - This is a relatively simple class, on the face of it. The standard - specifies very little in concrete terms, so generic - implementations that are conforming yet do very little are the - norm. Adding functionality that would be useful to programmers and - comparable to Java's java.text.MessageFormat takes a bit of work, - and is highly dependent on the capabilities of the underlying - operating system. -

    - Three different mechanisms have been provided, selectable via - configure flags: -

    • - generic -

      - This model does very little, and is what is used by default. -

    • - gnu -

      - The gnu model is complete and fully tested. It's based on the - GNU gettext package, which is part of glibc. It uses the - functions textdomain, bindtextdomain, gettext to - implement full functionality. Creating message catalogs is a - relatively straight-forward process and is lightly documented - below, and fully documented in gettext's distributed - documentation. -

    • - ieee_1003.1-200x -

      - This is a complete, though untested, implementation based on - the IEEE standard. The functions catopen, catgets, - catclose are used to retrieve locale-specific messages - given the appropriate message catalogs that have been - constructed for their use. Note, the script - po2msg.sed that is part of the gettext distribution can - convert gettext catalogs into catalogs that - catopen can use. -

    -A new, standards-conformant non-virtual member function signature was -added for 'open' so that a directory could be specified with a given -message catalog. This simplifies calling conventions for the gnu -model. -

    The GNU Model

    - The messages facet, because it is retrieving and converting - between characters sets, depends on the ctype and perhaps the - codecvt facet in a given locale. In addition, underlying "C" - library locale support is necessary for more than just the - LC_MESSAGES mask: LC_CTYPE is also - necessary. To avoid any unpleasantness, all bits of the "C" mask - (i.e. LC_ALL) are set before retrieving messages. -

    - Making the message catalogs can be initially tricky, but become - quite simple with practice. For complete info, see the gettext - documentation. Here's an idea of what is required: -

    • - Make a source file with the required string literals that need - to be translated. See intl/string_literals.cc for - an example. -

    • - Make initial catalog (see "4 Making the PO Template File" from - the gettext docs).

      - xgettext --c++ --debug string_literals.cc -o libstdc++.pot -

    • Make language and country-specific locale catalogs.

      - cp libstdc++.pot fr_FR.po -

      - cp libstdc++.pot de_DE.po -

    • - Edit localized catalogs in emacs so that strings are - translated. -

      - emacs fr_FR.po -

    • Make the binary mo files.

      - msgfmt fr_FR.po -o fr_FR.mo -

      - msgfmt de_DE.po -o de_DE.mo -

    • Copy the binary files into the correct directory structure.

      - cp fr_FR.mo (dir)/fr_FR/LC_MESSAGES/libstdc++.mo -

      - cp de_DE.mo (dir)/de_DE/LC_MESSAGES/libstdc++.mo -

    • Use the new message catalogs.

      - locale loc_de("de_DE"); -

      - - use_facet<messages<char> >(loc_de).open("libstdc++", locale(), dir); - -

    Use

    - A simple example using the GNU model of message conversion. - 

    -#include <iostream>
-#include <locale>
-using namespace std;
-
-void test01()
-{
-  typedef messages<char>::catalog catalog;
-  const char* dir =
-  "/mnt/egcs/build/i686-pc-linux-gnu/libstdc++/po/share/locale";  
-  const locale loc_de("de_DE");
-  const messages<char>& mssg_de = use_facet<messages<char> >(loc_de); 
-
-  catalog cat_de = mssg_de.open("libstdc++", loc_de, dir);
-  string s01 = mssg_de.get(cat_de, 0, 0, "please");
-  string s02 = mssg_de.get(cat_de, 0, 0, "thank you");
-  cout << "please in german:" << s01 << '\n';
-  cout << "thank you in german:" << s02 << '\n';
-  mssg_de.close(cat_de);
-}
-

    Future

    • - Things that are sketchy, or remain unimplemented: -

      • - _M_convert_from_char, _M_convert_to_char are in flux, - depending on how the library ends up doing character set - conversions. It might not be possible to do a real character - set based conversion, due to the fact that the template - parameter for messages is not enough to instantiate the - codecvt facet (1 supplied, need at least 2 but would prefer - 3). -

      • - There are issues with gettext needing the global locale set - to extract a message. This dependence on the global locale - makes the current "gnu" model non MT-safe. Future versions - of glibc, i.e. glibc 2.3.x will fix this, and the C++ library - bits are already in place. -

    • - Development versions of the GNU "C" library, glibc 2.3 will allow - a more efficient, MT implementation of std::messages, and will - allow the removal of the _M_name_messages data member. If this is - done, it will change the library ABI. The C++ parts to support - glibc 2.3 have already been coded, but are not in use: once this - version of the "C" library is released, the marked parts of the - messages implementation can be switched over to the new "C" - library functionality. -

    • - At some point in the near future, std::numpunct will probably use - std::messages facilities to implement truename/falsename - correctly. This is currently not done, but entries in - libstdc++.pot have already been made for "true" and "false" string - literals, so all that remains is the std::numpunct coding and the - configure/make hassles to make the installed library search its - own catalog. Currently the libstdc++.mo catalog is only searched - for the testsuite cases involving messages members. -

    • The following member functions:

      - - catalog - open(const basic_string<char>& __s, const locale& __loc) const - -

      - - catalog - open(const basic_string<char>&, const locale&, const char*) const; - -

      - Don't actually return a "value less than 0 if no such catalog - can be opened" as required by the standard in the "gnu" - model. As of this writing, it is unknown how to query to see - if a specified message catalog exists using the gettext - package. -

    Bibliography

    - The GNU C Library - . Roland McGrath. Ulrich Drepper. Copyright © 2007 FSF. Chapters 6 Character Set Handling, and 7 Locales and Internationalization - .

    - Correspondence - . Ulrich Drepper. Copyright © 2002 .

    - ISO/IEC 14882:1998 Programming languages - C++ - . Copyright © 1998 ISO.

    - ISO/IEC 9899:1999 Programming languages - C - . Copyright © 1999 ISO.

    - System Interface Definitions, Issue 6 (IEEE Std. 1003.1-200x) - . Copyright © 1999 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. - - - .

    - The C++ Programming Language, Special Edition - . Bjarne Stroustrup. Copyright © 2000 Addison Wesley, Inc.. Appendix D. - Addison Wesley - .

    - Standard C++ IOStreams and Locales - . - Advanced Programmer's Guide and Reference - . Angelika Langer. Klaus Kreft. Copyright © 2000 Addison Wesley Longman, Inc.. - Addison Wesley Longman - .

    - Java 2 Platform, Standard Edition, v 1.3.1 API Specification - . java.util.Properties, java.text.MessageFormat, -java.util.Locale, java.util.ResourceBundle. - - - .

    - GNU gettext tools, version 0.10.38, Native Language Support -Library and Tools. - . - - - .

    Prev Up Next
    codecvt Home Part VII.  - Containers - -
    diff --git a/libstdc++-v3/doc/html/manual/numerics.html b/libstdc++-v3/doc/html/manual/numerics.html dissimilarity index 87% index 57089cf47e8..de57145c948 100644 --- a/libstdc++-v3/doc/html/manual/numerics.html +++ b/libstdc++-v3/doc/html/manual/numerics.html @@ -1,9 +1,30 @@ - - -Part X.  Numerics
    Part X.  - Numerics - -
    Prev The GNU C++ Library Next

    Part X.  - Numerics - -

    Table of Contents

    21. Complex
    complex Processing
    22. Generalized Operations
    23. Interacting with C
    Numerics vs. Arrays
    C99
    Prev Up Next
    Chapter 20. Mutating Home Chapter 21. Complex
    + + +Chapter 12.  Numerics
    Chapter 12.  + Numerics + +
    Prev Part II.  + Standard Contents + Next

    Chapter 12.  + Numerics + +

    Table of Contents

    Complex
    complex Processing
    Generalized Operations
    Interacting with C
    Numerics vs. Arrays
    C99

    Complex

    +

    complex Processing

    +

    Using complex<> becomes even more comple- er, sorry, + complicated, with the not-quite-gratuitously-incompatible + addition of complex types to the C language. David Tribble has + compiled a list of C++98 and C99 conflict points; his description of + C's new type versus those of C++ and how to get them playing together + nicely is +here. +

    complex<> is intended to be instantiated with a + floating-point type. As long as you meet that and some other basic + requirements, then the resulting instantiation has all of the usual + math operators defined, as well as definitions of op<< + and op>> that work with iostreams: op<< + prints (u,v) and op>> can read u, + (u), and (u,v). +

    Prev Up Next
    Chapter 11.  + Algorithms + + Home Generalized Operations
    diff --git a/libstdc++-v3/doc/html/manual/numerics_and_c.html b/libstdc++-v3/doc/html/manual/numerics_and_c.html index 0bd1b809371..5102af670f3 100644 --- a/libstdc++-v3/doc/html/manual/numerics_and_c.html +++ b/libstdc++-v3/doc/html/manual/numerics_and_c.html @@ -1,9 +1,9 @@ -Chapter 23. Interacting with C
    Chapter 23. Interacting with C
    Prev Part X.  +Interacting with C
    Interacting with C
    Prev Chapter 12.  Numerics - Next

    Chapter 23. Interacting with C

    Table of Contents

    Numerics vs. Arrays
    C99

    Numerics vs. Arrays

    One of the major reasons why FORTRAN can chew through numbers so well +

    		 Next

    Interacting with C

    Numerics vs. Arrays

    One of the major reasons why FORTRAN can chew through numbers so well is that it is defined to be free of pointer aliasing, an assumption that C89 is not allowed to make, and neither is C++98. C99 adds a new keyword, restrict, to apply to individual pointers. The @@ -18,4 +18,20 @@ speaking this is only one of the five template classes, and they are designed to be familiar to people who have worked with the BLAS libraries before. -

    Prev Up Next
    Chapter 22. Generalized Operations Home C99
    +

    C99

    In addition to the other topics on this page, we'll note here some + of the C99 features that appear in libstdc++. +

    The C99 features depend on the --enable-c99 configure flag. + This flag is already on by default, but it can be disabled by the + user. Also, the configuration machinery will disable it if the + necessary support for C99 (e.g., header files) cannot be found. +

    As of GCC 3.0, C99 support includes classification functions + such as isnormal, isgreater, + isnan, etc. + The functions used for 'long long' support such as strtoll + are supported, as is the lldiv_t typedef. Also supported + are the wide character functions using 'long long', like + wcstoll. +

    Prev Up Next
    Generalized Operations Home Chapter 13.  + Input and Output + +
    diff --git a/libstdc++-v3/doc/html/manual/pairs.html b/libstdc++-v3/doc/html/manual/pairs.html index 3b4981bbaa8..719c987df20 100644 --- a/libstdc++-v3/doc/html/manual/pairs.html +++ b/libstdc++-v3/doc/html/manual/pairs.html @@ -1,9 +1,9 @@ -Chapter 10. Pairs
    Chapter 10. Pairs
    Prev Part IV.  +Pairs
    Pairs
    Prev Chapter 6.  Utilities - Next

    Chapter 10. Pairs

    The pair<T1,T2> is a simple and handy way to +

    		 Next

    Pairs

    The pair<T1,T2> is a simple and handy way to carry around a pair of objects. One is of type T1, and another of type T2; they may be the same type, but you don't get anything extra if they are. The two members can be accessed directly, as @@ -31,7 +31,7 @@ is defined as evaluating to: 

         x.first  <  y.first  ||
-        ( !(y.first  <  x.first)  &&  x.second  <  y.second )
+	( !(y.first  <  x.first)  &&  x.second  <  y.second )

    The other operators are not defined using the rel_ops functions above, but their semantics are the same.

    Finally, there is a template function called make_pair @@ -39,4 +39,7 @@ instance of a pair instantiated on their respective types: 

         pair<int,MyClass> p = make_pair(4,myobject);
-
    Prev Up Next
    Chapter 9. Functors Home Chapter 11. Memory
    +
    Prev Up Next
    Chapter 6.  + Utilities + + Home Memory
    diff --git a/libstdc++-v3/doc/html/manual/parallel_mode.html b/libstdc++-v3/doc/html/manual/parallel_mode.html index a21c3a65b2d..b8993b5c9d2 100644 --- a/libstdc++-v3/doc/html/manual/parallel_mode.html +++ b/libstdc++-v3/doc/html/manual/parallel_mode.html @@ -1,9 +1,9 @@ -Chapter 31. Parallel Mode
    Chapter 31. Parallel Mode
    Prev Part XII.  +Chapter 18. Parallel Mode
    Chapter 18. Parallel Mode
    Prev Part III.  Extensions - Next

    Chapter 31. Parallel Mode

    Table of Contents

    Intro
    Semantics
    Using
    Prerequisite Compiler Flags
    Using Parallel Mode
    Using Specific Parallel Components
    Design
    Interface Basics
    Configuration and Tuning
    Implementation Namespaces
    Testing
    Bibliography

    The libstdc++ parallel mode is an experimental parallel +

    		 Next

    Chapter 18. Parallel Mode

    Table of Contents

    Intro
    Semantics
    Using
    Prerequisite Compiler Flags
    Using Parallel Mode
    Using Specific Parallel Components
    Design
    Interface Basics
    Configuration and Tuning
    Implementation Namespaces
    Testing
    Bibliography

    The libstdc++ parallel mode is an experimental parallel implementation of many algorithms the C++ Standard Library.

    Several of the standard algorithms, for instance @@ -13,12 +13,12 @@ explicit source declaration or by compiling existing sources with a specific compiler flag.

    Intro

    The following library components in the include numeric are included in the parallel mode:

    • std::accumulate

    • std::adjacent_difference

    • std::inner_product

    • std::partial_sum

    The following library components in the include -algorithm are included in the parallel mode:

    • std::adjacent_find

    • std::count

    • std::count_if

    • std::equal

    • std::find

    • std::find_if

    • std::find_first_of

    • std::for_each

    • std::generate

    • std::generate_n

    • std::lexicographical_compare

    • std::mismatch

    • std::search

    • std::search_n

    • std::transform

    • std::replace

    • std::replace_if

    • std::max_element

    • std::merge

    • std::min_element

    • std::nth_element

    • std::partial_sort

    • std::partition

    • std::random_shuffle

    • std::set_union

    • std::set_intersection

    • std::set_symmetric_difference

    • std::set_difference

    • std::sort

    • std::stable_sort

    • std::unique_copy

    Bibliography

    +algorithm are included in the parallel mode:

    • std::adjacent_find

    • std::count

    • std::count_if

    • std::equal

    • std::find

    • std::find_if

    • std::find_first_of

    • std::for_each

    • std::generate

    • std::generate_n

    • std::lexicographical_compare

    • std::mismatch

    • std::search

    • std::search_n

    • std::transform

    • std::replace

    • std::replace_if

    • std::max_element

    • std::merge

    • std::min_element

    • std::nth_element

    • std::partial_sort

    • std::partition

    • std::random_shuffle

    • std::set_union

    • std::set_intersection

    • std::set_symmetric_difference

    • std::set_difference

    • std::sort

    • std::stable_sort

    • std::unique_copy

    Bibliography

    Parallelization of Bulk Operations for STL Dictionaries . Johannes Singler. Leonor Frias. Copyright © 2007 . Workshop on Highly Parallel Processing on a Chip (HPPC) 2007. (LNCS) - .

    + .

    The Multi-Core Standard Template Library . Johannes Singler. Peter Sanders. Felix Putze. Copyright © 2007 . Euro-Par 2007: Parallel Processing. (LNCS 4641) - .

    Prev Up Next
    Design Home Semantics
    + .

    Prev Up Next
    Design Home Semantics
    diff --git a/libstdc++-v3/doc/html/manual/profile_mode.html b/libstdc++-v3/doc/html/manual/profile_mode.html index 408dba26f79..8fc828ef1e3 100644 --- a/libstdc++-v3/doc/html/manual/profile_mode.html +++ b/libstdc++-v3/doc/html/manual/profile_mode.html @@ -1,9 +1,9 @@ -Chapter 32. Profile Mode
    Chapter 32. Profile Mode
    Prev Part XII.  +Chapter 19. Profile Mode
    Chapter 19. Profile Mode
    Prev Part III.  Extensions - Next

    Chapter 32. Profile Mode

    Table of Contents

    Intro
    Using the Profile Mode
    Tuning the Profile Mode
    Design
    Wrapper Model
    Instrumentation
    Run Time Behavior
    Analysis and Diagnostics
    Cost Model
    Reports
    Testing
    Extensions for Custom Containers
    Empirical Cost Model
    Implementation Issues
    Stack Traces
    Symbolization of Instruction Addresses
    Concurrency
    Using the Standard Library in the Instrumentation Implementation
    Malloc Hooks
    Construction and Destruction of Global Objects
    Developer Information
    Big Picture
    How To Add A Diagnostic
    Diagnostics
    Diagnostic Template
    Containers
    Algorithms
    Data Locality
    Multithreaded Data Access
    Statistics
    Bibliography

    Intro

    +

    		 Next

    Chapter 19. Profile Mode

    Table of Contents

    Intro
    Using the Profile Mode
    Tuning the Profile Mode
    Design
    Wrapper Model
    Instrumentation
    Run Time Behavior
    Analysis and Diagnostics
    Cost Model
    Reports
    Testing
    Extensions for Custom Containers
    Empirical Cost Model
    Implementation Issues
    Stack Traces
    Symbolization of Instruction Addresses
    Concurrency
    Using the Standard Library in the Instrumentation Implementation
    Malloc Hooks
    Construction and Destruction of Global Objects
    Developer Information
    Big Picture
    How To Add A Diagnostic
    Diagnostics
    Diagnostic Template
    Containers
    Algorithms
    Data Locality
    Multithreaded Data Access
    Statistics
    Bibliography

    Intro

    Goal: Give performance improvement advice based on recognition of suboptimal usage patterns of the standard library.

    @@ -11,13 +11,13 @@ calls to an instrumentation library to record the internal state of various components at interesting entry/exit points to/from the standard library. Process trace, recognize suboptimal patterns, give advice. - For details, see + For details, see paper presented at CGO 2009.

    Strengths:

    • - Unintrusive solution. The application code does not require any + Unintrusive solution. The application code does not require any modification.

    • The advice is call context sensitive, thus capable of identifying precisely interesting dynamic performance behavior. @@ -75,7 +75,7 @@ vector-size: improvement = 3: call stack = 0x804842c ... The warning message. For some warnings, this is static text, e.g., "change vector to list". For other warnings, such as the one above, the message contains numeric advice, e.g., the suggested initial size - of the hashtable. + of the vector.

    Three files are generated. libstdcxx-profile.txt contains human readable advice. libstdcxx-profile.raw @@ -108,7 +108,7 @@ vector-size: improvement = 3: call stack = 0x804842c ... path for the output files.

  • _GLIBCXX_PROFILE_MAX_WARN_COUNT: set it to the maximum number of warnings desired. The default value is 10.

  • - _GLIBCXX_PROFILE_MAX_STACK_DEPTH: if set to 0, + _GLIBCXX_PROFILE_MAX_STACK_DEPTH: if set to 0, the advice will be collected and reported for the program as a whole, and not for each call context. @@ -124,10 +124,10 @@ vector-size: improvement = 3: call stack = 0x804842c ... live containers are deleted. The default is 128 MB.

  • _GLIBCXX_PROFILE_NO_THREADS: - Make the library not use threads. If thread local storage (TLS) is not + Make the library not use threads. If thread local storage (TLS) is not available, you will get a preprocessor error asking you to set -D_GLIBCXX_PROFILE_NO_THREADS if your program is single-threaded. - Multithreded execution without TLS is not supported. + Multithreaded execution without TLS is not supported. (Environment variable not supported.)

  • _GLIBCXX_HAVE_EXECINFO_H: @@ -138,9 +138,9 @@ vector-size: improvement = 3: call stack = 0x804842c ... call context. (Environment variable not supported.)

    • -

    Bibliography

    +

    Bibliography

    Perflint: A Context Sensitive Performance Advisor for C++ Programs . Lixia Liu. Silvius Rus. Copyright © 2009 . Proceedings of the 2009 International Symposium on Code Generation - and Optimization - .

    Prev Up Next
    Testing Home Design
    + and Optimization + .

    Prev Up Next
    Testing Home Design
    diff --git a/libstdc++-v3/doc/html/manual/sequences.html b/libstdc++-v3/doc/html/manual/sequences.html deleted file mode 100644 index fd3ff148e54..00000000000 --- a/libstdc++-v3/doc/html/manual/sequences.html +++ /dev/null @@ -1,43 +0,0 @@ - - -Chapter 16. Sequences
    Chapter 16. Sequences
    Prev Part VII.  - Containers - - Next

    Chapter 16. Sequences

    Table of Contents

    list
    list::size() is O(n)
    vector
    Space Overhead Management

    list

    list::size() is O(n)

    - Yes it is, and that's okay. This is a decision that we preserved - when we imported SGI's STL implementation. The following is - quoted from their FAQ: -

    - The size() member function, for list and slist, takes time - proportional to the number of elements in the list. This was a - deliberate tradeoff. The only way to get a constant-time - size() for linked lists would be to maintain an extra member - variable containing the list's size. This would require taking - extra time to update that variable (it would make splice() a - linear time operation, for example), and it would also make the - list larger. Many list algorithms don't require that extra - word (algorithms that do require it might do better with - vectors than with lists), and, when it is necessary to maintain - an explicit size count, it's something that users can do - themselves. -

    - This choice is permitted by the C++ standard. The standard says - that size() “should” be constant time, and - “should” does not mean the same thing as - “shall”. This is the officially recommended ISO - wording for saying that an implementation is supposed to do - something unless there is a good reason not to. -

    - One implication of linear time size(): you should never write - 

    -         if (L.size() == 0)
-             ...
-

    - Instead, you should write - 

    -         if (L.empty())
-             ...
-
    Prev Up Next
    Part VII.  - Containers - - Home vector
    diff --git a/libstdc++-v3/doc/html/manual/setup.html b/libstdc++-v3/doc/html/manual/setup.html index b0c491e544a..23de8cc5219 100644 --- a/libstdc++-v3/doc/html/manual/setup.html +++ b/libstdc++-v3/doc/html/manual/setup.html @@ -23,7 +23,7 @@ Because libstdc++ is part of GCC, the primary source for installation instructions is the GCC install page. - In particular, list of prerequisite software needed to build the library + In particular, list of prerequisite software needed to build the library starts with those requirements. The same pages also list the tools you will need if you wish to modify the source. @@ -40,7 +40,11 @@ The configure process will automatically detect and use these features if the underlying support is present.

    - Finally, a few system-specific requirements: + To generate the API documentation from the sources you will need + Doxygen, see Documentation + Style in the appendix for full details. +

    + Finally, a few system-specific requirements:

    linux

    If gcc 3.1.0 or later on is being used on linux, an attempt will be made to use "C" library functionality necessary for @@ -90,12 +94,12 @@ zh_TW BIG5

    To install support for locales, do only one of the following:

    • install all locales

      • with RedHat Linux: -

        export LC_ALL=C -

        rpm -e glibc-common --nodeps -

        +

        export LC_ALL=C +

        rpm -e glibc-common --nodeps +

        rpm -i --define "_install_langs all" - glibc-common-2.2.5-34.i386.rpm - + glibc-common-2.2.5-34.i386.rpm +

      • Instructions for other operating systems solicited.

    • install just the necessary locales

      • with Debian Linux:

        Add the above list, as shown, to the file diff --git a/libstdc++-v3/doc/html/manual/shared_ptr.html b/libstdc++-v3/doc/html/manual/shared_ptr.html deleted file mode 100644 index 59666b93b16..00000000000 --- a/libstdc++-v3/doc/html/manual/shared_ptr.html +++ /dev/null @@ -1,304 +0,0 @@ - - -shared_ptr

        shared_ptr
        Prev Chapter 11. Memory Next

        shared_ptr

        -The shared_ptr class template stores a pointer, usually obtained via new, -and implements shared ownership semantics. -

        Requirements

        -

        - The standard deliberately doesn't require a reference-counted - implementation, allowing other techniques such as a - circular-linked-list. -

        - At the time of writing the C++0x working paper doesn't mention how - threads affect shared_ptr, but it is likely to follow the existing - practice set by boost::shared_ptr. The - shared_ptr in libstdc++ is derived from Boost's, so the same rules - apply. -

        -

        Design Issues

        -The shared_ptr code is kindly donated to GCC by the Boost -project and the original authors of the code. The basic design and -algorithms are from Boost, the notes below describe details specific to -the GCC implementation. Names have been uglified in this implementation, -but the design should be recognisable to anyone familiar with the Boost -1.32 shared_ptr. -

        -The basic design is an abstract base class, _Sp_counted_base that -does the reference-counting and calls virtual functions when the count -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. -

        Implementation

        Class Hierarchy

        -A shared_ptr<T> contains a pointer of -type T* and an object of type -__shared_count. The shared_count contains a -pointer of type _Sp_counted_base* which points to the -object that maintains the reference-counts and destroys the managed -resource. -

        _Sp_counted_base<Lp>

        -The base of the hierarchy is parameterized on the lock policy alone. -_Sp_counted_base doesn't depend on the type of pointer being managed, -it only maintains the reference counts and calls virtual functions when -the counts drop to zero. The managed object is destroyed when the last -strong reference is dropped, but the _Sp_counted_base itself must exist -until the last weak reference is dropped. -

        _Sp_counted_base_impl<Ptr, Deleter, Lp>

        -Inherits from _Sp_counted_base and stores a pointer of type Ptr -and a deleter of type Deleter. _Sp_deleter is -used when the user doesn't supply a custom deleter. Unlike Boost's, this -default deleter is not "checked" because GCC already issues a warning if -delete is used with an incomplete type. -This is the only derived type used by shared_ptr<Ptr> -and it is never used by shared_ptr, which uses one of -the following types, depending on how the shared_ptr is constructed. -

        _Sp_counted_ptr<Ptr, Lp>

        -Inherits from _Sp_counted_base and stores a pointer of type Ptr, -which is passed to delete when the last reference is dropped. -This is the simplest form and is used when there is no custom deleter or -allocator. -

        _Sp_counted_deleter<Ptr, Deleter, Alloc>

        -Inherits from _Sp_counted_ptr and adds support for custom deleter and -allocator. Empty Base Optimization is used for the allocator. This class -is used even when the user only provides a custom deleter, in which case -allocator is used as the allocator. -

        _Sp_counted_ptr_inplace<Tp, Alloc, Lp>

        -Used by allocate_shared and make_shared. -Contains aligned storage to hold an object of type Tp, -which is constructed in-place with placement new. -Has a variadic template constructor allowing any number of arguments to -be forwarded to Tp's constructor. -Unlike the other _Sp_counted_* classes, this one is parameterized on the -type of object, not the type of pointer; this is purely a convenience -that simplifies the implementation slightly. -

        Thread Safety

        -The interface of tr1::shared_ptr was extended for C++0x -with support for rvalue-references and the other features from -N2351. As with other libstdc++ headers shared by TR1 and C++0x, -boost_shared_ptr.h uses conditional compilation, based on the macros -_GLIBCXX_INCLUDE_AS_CXX0X and -_GLIBCXX_INCLUDE_AS_TR1, to enable and disable -features. -

        -C++0x-only features are: rvalue-ref/move support, allocator support, -aliasing constructor, make_shared & allocate_shared. Additionally, -the constructors taking auto_ptr parameters are -deprecated in C++0x mode. -

        -The -Thread -Safety section of the Boost shared_ptr documentation says "shared_ptr -objects offer the same level of thread safety as built-in types." -The implementation must ensure that concurrent updates to separate shared_ptr -instances are correct even when those instances share a reference count e.g. -

        -shared_ptr<A> a(new A);
-shared_ptr<A> b(a);
-
-// Thread 1     // Thread 2
-   a.reset();      b.reset();
-

        -The dynamically-allocated object must be destroyed by exactly one of the -threads. Weak references make things even more interesting. -The shared state used to implement shared_ptr must be transparent to the -user and invariants must be preserved at all times. -The key pieces of shared state are the strong and weak reference counts. -Updates to these need to be atomic and visible to all threads to ensure -correct cleanup of the managed resource (which is, after all, shared_ptr's -job!) -On multi-processor systems memory synchronisation may be needed so that -reference-count updates and the destruction of the managed resource are -race-free. -

        -The function _Sp_counted_base::_M_add_ref_lock(), called when -obtaining a shared_ptr from a weak_ptr, has to test if the managed -resource still exists and either increment the reference count or throw -bad_weak_ptr. -In a multi-threaded program there is a potential race condition if the last -reference is dropped (and the managed resource destroyed) between testing -the reference count and incrementing it, which could result in a shared_ptr -pointing to invalid memory. -

        -The Boost shared_ptr (as used in GCC) features a clever lock-free -algorithm to avoid the race condition, but this relies on the -processor supporting an atomic Compare-And-Swap -instruction. For other platforms there are fall-backs using mutex -locks. Boost (as of version 1.35) includes several different -implementations and the preprocessor selects one based on the -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. -

        Selecting Lock Policy

        -

        -There is a single _Sp_counted_base class, -which is a template parameterized on the enum -__gnu_cxx::_Lock_policy. The entire family of classes is -parameterized on the lock policy, right up to -__shared_ptr, __weak_ptr and -__enable_shared_from_this. The actual -std::shared_ptr class inherits from -__shared_ptr with the lock policy parameter -selected automatically based on the thread model and platform that -libstdc++ is configured for, so that the best available template -specialization will be used. This design is necessary because it would -not be conforming for shared_ptr to have an -extra template parameter, even if it had a default value. The -available policies are: -

        1. - _S_Atomic -

          -Selected when GCC supports a builtin atomic compare-and-swap operation -on the target processor (see Atomic -Builtins.) The reference counts are maintained using a lock-free -algorithm and GCC's atomic builtins, which provide the required memory -synchronisation. -

        2. - _S_Mutex -

          -The _Sp_counted_base specialization for this policy contains a mutex, -which is locked in add_ref_lock(). This policy is used when GCC's atomic -builtins aren't available so explicit memory barriers are needed in places. -

        3. - _S_Single -

          -This policy uses a non-reentrant add_ref_lock() with no locking. It is -used when libstdc++ is built without --enable-threads. -

        - For all three policies, reference count increments and - decrements are done via the functions in - ext/atomicity.h, 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. -

        Dual C++0x and TR1 Implementation

        -The classes derived from _Sp_counted_base (see Class Hierarchy -below) and __shared_count are implemented separately for C++0x -and TR1, in bits/boost_sp_shared_count.h and -tr1/boost_sp_shared_count.h respectively. All other classes -including _Sp_counted_base are shared by both implementations. -

        -The TR1 implementation is considered relatively stable, so is unlikely to -change unless bug fixes require it. If the code that is common to both -C++0x and TR1 modes needs to diverge further then it might be necessary to -duplicate additional classes and only make changes to the C++0x versions. -

        Related functions and classes

        dynamic_pointer_cast, static_pointer_cast, -const_pointer_cast

        -As noted in N2351, these functions can be implemented non-intrusively using -the alias constructor. However the aliasing constructor is only available -in C++0x mode, so in TR1 mode these casts rely on three non-standard -constructors in shared_ptr and __shared_ptr. -In C++0x mode these constructors and the related tag types are not needed. -

        enable_shared_from_this

        -The clever overload to detect a base class of type -enable_shared_from_this comes straight from Boost. -There is an extra overload for __enable_shared_from_this to -work smoothly with __shared_ptr<Tp, Lp> using any lock -policy. -

        make_shared, allocate_shared

        -make_shared simply forwards to allocate_shared -with std::allocator as the allocator. -Although these functions can be implemented non-intrusively using the -alias constructor, if they have access to the implementation then it is -possible to save storage and reduce the number of heap allocations. The -newly constructed object and the _Sp_counted_* can be allocated in a single -block and the standard says implementations are "encouraged, but not required," -to do so. This implementation provides additional non-standard constructors -(selected with the type _Sp_make_shared_tag) which create an -object of type _Sp_counted_ptr_inplace to hold the new object. -The returned shared_ptr<A> needs to know the address of the -new A object embedded in the _Sp_counted_ptr_inplace, -but it has no way to access it. -This implementation uses a "covert channel" to return the address of the -embedded object when get_deleter<_Sp_make_shared_tag>() -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. -

        Use

        Examples

        - Examples of use can be found in the testsuite, under - testsuite/tr1/2_general_utilities/shared_ptr. -

        Unresolved Issues

        - The resolution to C++ Standard Library issue 674, - "shared_ptr interface changes for consistency with N1856" will - need to be implemented after it is accepted into the working - paper. Issue 743 - might also require changes. -

        - The _S_single policy uses atomics when used in MT - code, because it uses the same dispatcher functions that check - __gthread_active_p(). This could be - addressed by providing template specialisations for some members - of _Sp_counted_base<_S_single>. -

        - Unlike Boost, this implementation does not use separate classes - for the pointer+deleter and pointer+deleter+allocator cases in - C++0x mode, combining both into _Sp_counted_deleter and using - allocator when the user doesn't specify - an allocator. If it was found to be beneficial an additional - class could easily be added. With the current implementation, - the _Sp_counted_deleter and __shared_count constructors taking a - custom deleter but no allocator are technically redundant and - could be removed, changing callers to always specify an - allocator. If a separate pointer+deleter class was added the - __shared_count constructor would be needed, so it has been kept - for now. -

        - The hack used to get the address of the managed object from - _Sp_counted_ptr_inplace::_M_get_deleter() - is accessible to users. This could be prevented if - get_deleter<_Sp_make_shared_tag>() - always returned NULL, since the hack only needs to work at a - lower level, not in the public API. This wouldn't be difficult, - but hasn't been done since there is no danger of accidental - misuse: users already know they are relying on unsupported - features if they refer to implementation details such as - _Sp_make_shared_tag. -

        - tr1::_Sp_deleter could be a private member of tr1::__shared_count but it - would alter the ABI. -

        - Exposing the alias constructor in TR1 mode could simplify the - *_pointer_cast functions. Constructor could be private in TR1 - mode, with the cast functions as friends. -

        Acknowledgments

        - The original authors of the Boost shared_ptr, which is really nice - 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. -

        Bibliography

        [ - n2351 - ] - Improving shared_ptr for C++0x, Revision 2 - . - N2351 - . - - - .

        [ - n2456 - ] - C++ Standard Library Active Issues List (Revision R52) - . - N2456 - . - - - .

        [ - n2461 - ] - Working Draft, Standard for Programming Language C++ - . - N2461 - . - - - .

        [ - boostshared_ptr - ] - Boost C++ Libraries documentation - shared_ptr class template - . - N2461 - . - shared_ptr - - .

        Prev Up Next
        auto_ptr Home Chapter 12. Traits
        diff --git a/libstdc++-v3/doc/html/manual/source_code_style.html b/libstdc++-v3/doc/html/manual/source_code_style.html index 8b9932cd032..dc4e49067ff 100644 --- a/libstdc++-v3/doc/html/manual/source_code_style.html +++ b/libstdc++-v3/doc/html/manual/source_code_style.html @@ -60,7 +60,7 @@       these names as operators have been fixed.]

              The full set of __* identifiers (combined from gcc/cp/lex.c and
        -      gcc/cplus-dem.c) that are either old or new, but are definitely 
        +      gcc/cplus-dem.c) that are either old or new, but are definitely
              recognized by the demangler, is:

              __aa
        @@ -225,8 +225,8 @@       -NOT-
              char *p = "flop";  // wrong
              char &c = *p;      // wrong
        -      
        -      Reason: In C++, definitions are mixed with executable code. Here,       
        +
        +      Reason: In C++, definitions are mixed with executable code. Here,
              p is being initialized, not *p. This is near-universal
              practice among C++ programmers; it is normal for C hackers
              to switch spontaneously as they gain experience.
        @@ -235,9 +235,9 @@       operator==(type)
              -NOT-
              operator == (type)  // wrong
        -      
        +
              Reason: The == is part of the function name. Separating
        -      it makes the declaration look like an expression. 
        +      it makes the declaration look like an expression.

              03. Function names and parentheses
              void mangle()
        @@ -246,22 +246,22 @@
              Reason: no space before parentheses (except after a control-flow
              keyword) is near-universal practice for C++. It identifies the
        -      parentheses as the function-call operator or declarator, as 
        +      parentheses as the function-call operator or declarator, as
              opposed to an expression or other overloaded use of parentheses.

              04. Template function indentation
              template<typename T>
        -      void 
        +      void
              template_function(args)
              { }
              -NOT-
              template<class T>
              void template_function(args) {};
        -      
        +
              Reason: In class definitions, without indentation whitespace is
              needed both above and below the declaration to distinguish
              it visually from other members. (Also, re: "typename"
        -      rather than "class".)  T often could be int, which is 
        +      rather than "class".)  T often could be int, which is
              not a class. ("class", here, is an anachronism.)

              05. Template class indentation
        @@ -299,7 +299,7 @@       07. Member initialization lists
              All one line, separate from class name.

        -      gribble::gribble() 
        +      gribble::gribble()
              : _M_private_data(0), _M_more_stuff(0), _M_helper(0);
              { }
              -NOT-
        @@ -307,18 +307,18 @@       { }

              08. Try/Catch blocks
        -      try 
        +      try
              {
              //
        -      }   
        +      }
              catch (...)
              {
              //
        -      }   
        +      }
              -NOT-
              try {
        -      // 
        -      } catch(...) { 
        +      //
        +      } catch(...) {
              //
              }

        @@ -326,7 +326,7 @@       Keywords such as extern, static, export, explicit, inline, etc
              go on the line above the function name. Thus

        -      virtual int   
        +      virtual int
              foo()
              -NOT-
              virtual int foo()
        @@ -369,7 +369,7 @@
              -NOT-
              public:
        -      
        +
              int foo;

              13. Spacing WRT return statements.
        @@ -428,17 +428,17 @@
              Name patterns:

        -      For nonstandard names appearing in Standard headers, we are constrained 
        +      For nonstandard names appearing in Standard headers, we are constrained
              to use names that begin with underscores. This is called "uglification".
              The convention is:

              Local and argument names:  __[a-z].*

        -      Examples:  __count  __ix  __s1  
        +      Examples:  __count  __ix  __s1

              Type names and template formal-argument names: _[A-Z][^_].*

        -      Examples:  _Helper  _CharT  _N 
        +      Examples:  _Helper  _CharT  _N

              Member data and function names: _M_.*

        @@ -448,7 +448,7 @@
              Examples: _S_max_elements  _S_default_value

        -      Don't use names in the same scope that differ only in the prefix, 
        +      Don't use names in the same scope that differ only in the prefix,
              e.g. _S_top and _M_top. See BADNAMES for a list of forbidden names.
              (The most tempting of these seem to be and "_T" and "__sz".)

        @@ -458,7 +458,7 @@       --------------------------

              [BY EXAMPLE]
        -      
        +
              #ifndef  _HEADER_
              #define  _HEADER_ 1

        @@ -471,37 +471,37 @@
              gribble(const gribble&);

        -      explicit 
        +      explicit
              gribble(int __howmany);

        -      gribble& 
        +      gribble&
              operator=(const gribble&);

        -      virtual 
        +      virtual
              ~gribble() throw ();

              // Start with a capital letter, end with a period.
        -      inline void  
        +      inline void
              public_member(const char* __arg) const;

              // In-class function definitions should be restricted to one-liners.
        -      int 
        +      int
              one_line() { return 0 }

        -      int 
        -      two_lines(const char* arg) 
        +      int
        +      two_lines(const char* arg)
              { return strchr(arg, 'a'); }

        -      inline int 
        +      inline int
              three_lines();  // inline, but defined below.

              // Note indentation.
              template<typename _Formal_argument>
        -      void 
        +      void
              public_template() const throw();

              template<typename _Iterator>
        -      void 
        +      void
              other_template();

              private:
        @@ -512,13 +512,13 @@       _Helper* _M_helper;
              int _M_private_function();

        -      enum _Enum 
        -      { 
        -      _S_one, 
        -      _S_two 
        +      enum _Enum
        +      {
        +      _S_one,
        +      _S_two
              };

        -      static void 
        +      static void
              _S_initialize_library();
              };

        @@ -548,20 +548,20 @@       #endif /* _HEADER_ */


        -      namespace std 
        +      namespace std
              {
              template<typename T>  // notice: "typename", not "class", no space
        -      long_return_value_type<with_many, args>  
        +      long_return_value_type<with_many, args>
              function_name(char* pointer,               // "char *pointer" is wrong.
        -      char* argument, 
        +      char* argument,
              const Reference& ref)
              {
              // int a_local;  /* wrong; see below. */
        -      if (test) 
        -      { 
        -      nested code 
        +      if (test)
        +      {
        +      nested code
              }
        -      
        +
              int a_local = 0;  // declare variable at first use.

              //  char a, b, *p;   /* wrong */
        @@ -574,12 +574,12 @@       // ...
              }
              }
        -      
        +
              gribble::gribble()
              : _M_private_data(0), _M_more_stuff(0), _M_helper(0);
              { }

        -      inline int 
        +      inline int
              gribble::three_lines()
              {
              // doesn't fit in one line.
        diff --git a/libstdc++-v3/doc/html/manual/source_organization.html b/libstdc++-v3/doc/html/manual/source_organization.html index 2ac9f9041a3..4cb92481af7 100644 --- a/libstdc++-v3/doc/html/manual/source_organization.html +++ b/libstdc++-v3/doc/html/manual/source_organization.html @@ -20,26 +20,26 @@ It has subdirectories:

            include/std
              Files meant to be found by #include <name> directives in
        -      standard-conforming user programs.  
        +      standard-conforming user programs.

            include/c
        -      Headers intended to directly include standard C headers. 
        +      Headers intended to directly include standard C headers.
              [NB: this can be enabled via --enable-cheaders=c]

        -    include/c_global 
        +    include/c_global
              Headers intended to include standard C headers in
              the global namespace, and put select names into the std::
              namespace.  [NB: this is the default, and is the same as
              --enable-cheaders=c_global]

        -    include/c_std 
        +    include/c_std
              Headers intended to include standard C headers
              already in namespace std, and put select names into the std::
              namespace.  [NB: this is the same as --enable-cheaders=c_std]

            include/bits
              Files included by standard headers and by other files in
        -      the bits directory. 
        +      the bits directory.

            include/backward
              Headers provided for backward compatibility, such as <iostream.h>.
        @@ -58,7 +58,7 @@ It has subdirectories:
            installed.

          testsuites/[backward, demangle, ext, performance, thread, 17_* to 27_*]
        -    Test programs are here, and may be used to begin to exercise the 
        +    Test programs are here, and may be used to begin to exercise the
            library.  Support for "make check" and "make check-install" is
            complete, and runs through all the subdirectories here when this
            command is issued from the build directory.  Please note that
        diff --git a/libstdc++-v3/doc/html/manual/spine.html b/libstdc++-v3/doc/html/manual/spine.html index f5e3d1ebd3a..bbc038e09bd 100644 --- a/libstdc++-v3/doc/html/manual/spine.html +++ b/libstdc++-v3/doc/html/manual/spine.html @@ -2,48 +2,58 @@ The GNU C++ Library
        The GNU C++ Library
        Prev   Next

        The GNU C++ Library

        Copyright © 2009, 2010 FSF -

        Table of Contents

        I. Introduction -
        1. Status
        Implementation Status
        C++ 1998/2003
        C++ 200x
        C++ TR1
        C++ TR 24733
        License
        The Code: GPL
        The Documentation: GPL, FDL
        Bugs
        Implementation Bugs
        Standard Bugs
        2. Setup
        Prerequisites
        Configure
        Make
        3. Using
        Command Options
        Headers
        Header Files
        Mixing Headers
        The C Headers and namespace std
        Precompiled Headers
        Macros
        Namespaces
        Available Namespaces
        namespace std
        Using Namespace Composition
        Linking
        Almost Nothing
        Finding Dynamic or Shared Libraries
        Concurrency
        Prerequisites
        Thread Safety
        Atomics
        IO
        Containers
        Exceptions
        Exception Safety
        Exception Neutrality
        Doing without
        Compatibility
        Debugging Support
        Using g++
        Debug Versions of Library Binary Files
        Memory Leak Hunting
        Using gdb
        Tracking uncaught exceptions
        Debug Mode
        Compile Time Checking
        Profile-based Performance Analysis
        II. +
        1. Status
        Implementation Status
        C++ 1998/2003
        C++ 200x
        C++ TR1
        C++ TR 24733
        License
        The Code: GPL
        The Documentation: GPL, FDL
        Bugs
        Implementation Bugs
        Standard Bugs
        2. Setup
        Prerequisites
        Configure
        Make
        3. Using
        Command Options
        Headers
        Header Files
        Mixing Headers
        The C Headers and namespace std
        Precompiled Headers
        Macros
        Namespaces
        Available Namespaces
        namespace std
        Using Namespace Composition
        Linking
        Almost Nothing
        Finding Dynamic or Shared Libraries
        Concurrency
        Prerequisites
        Thread Safety
        Atomics
        IO
        Containers
        Exceptions
        Exception Safety
        Exception Neutrality
        Doing without
        Compatibility
        Debugging Support
        Using g++
        Debug Versions of Library Binary Files
        Memory Leak Hunting
        Using gdb
        Tracking uncaught exceptions
        Debug Mode
        Compile Time Checking
        Profile-based Performance Analysis
        II. + Standard Contents +
        4. Support -
        4. Types
        Fundamental Types
        Numeric Properties
        NULL
        5. Dynamic Memory
        6. Termination
        Termination Handlers
        Verbose Terminate Handler
        III. +
        Types
        Fundamental Types
        Numeric Properties
        NULL
        Dynamic Memory
        Termination
        Termination Handlers
        Verbose Terminate Handler
        5. Diagnostics -
        7. Exceptions
        Exception Classes
        Adding Data to Exceptions
        8. Concept Checking
        IV. +
        Exceptions
        API Reference
        Adding Data to exception
        Concept Checking
        6. Utilities -
        9. Functors
        10. Pairs
        11. Memory
        Allocators
        Requirements
        Design Issues
        Implementation
        Using a Specific Allocator
        Custom Allocators
        Extension Allocators
        auto_ptr
        Limitations
        Use in Containers
        shared_ptr
        Requirements
        Design Issues
        Implementation
        Use
        Acknowledgments
        12. Traits
        V. +
        Functors
        Pairs
        Memory
        Allocators
        auto_ptr
        shared_ptr
        Traits
        7. Strings -
        13. String Classes
        Simple Transformations
        Case Sensitivity
        Arbitrary Character Types
        Tokenizing
        Shrink to Fit
        CString (MFC)
        VI. +
        String Classes
        Simple Transformations
        Case Sensitivity
        Arbitrary Character Types
        Tokenizing
        Shrink to Fit
        CString (MFC)
        8. Localization -
        14. Locales
        locale
        Requirements
        Design
        Implementation
        Future
        15. Facets aka Categories
        ctype
        Implementation
        Future
        codecvt
        Requirements
        Design
        Implementation
        Use
        Future
        messages
        Requirements
        Design
        Implementation
        Use
        Future
        VII. +
        Locales
        locale
        Facets
        ctype
        codecvt
        messages
        9. Containers -
        16. Sequences
        list
        list::size() is O(n)
        vector
        Space Overhead Management
        17. Associative
        Insertion Hints
        bitset
        Size Variable
        Type String
        18. Interacting with C
        Containers vs. Arrays
        VIII. +
        Sequences
        list
        vector
        Associative
        Insertion Hints
        bitset
        Interacting with C
        Containers vs. Arrays
        10. Iterators -
        19. Predefined
        Iterators vs. Pointers
        One Past the End
        IX. +
        Predefined
        Iterators vs. Pointers
        One Past the End
        11. Algorithms -
        20. Mutating
        swap
        Specializations
        X. +
        Mutating
        swap
        12. Numerics -
        21. Complex
        complex Processing
        22. Generalized Operations
        23. Interacting with C
        Numerics vs. Arrays
        C99
        XI. +
        Complex
        complex Processing
        Generalized Operations
        Interacting with C
        Numerics vs. Arrays
        C99
        13. Input and Output -
        24. Iostream Objects
        25. Stream Buffers
        Derived streambuf Classes
        Buffering
        26. Memory Based Streams
        Compatibility With strstream
        27. File Based Streams
        Copying a File
        Binary Input and Output
        28. Interacting with C
        Using FILE* and file descriptors
        Performance
        XII. +
        Iostream Objects
        Stream Buffers
        Derived streambuf Classes
        Buffering
        Memory Based Streams
        Compatibility With strstream
        File Based Streams
        Copying a File
        Binary Input and Output
        Interacting with C
        Using FILE* and file descriptors
        Performance
        14. + Atomics + +
        API Reference
        15. + Concurrency + +
        API Reference
        III. Extensions -
        29. Compile Time Checks
        30. Debug Mode
        Intro
        Semantics
        Using
        Using the Debug Mode
        Using a Specific Debug Container
        Design
        Goals
        Methods
        Other Implementations
        31. Parallel Mode
        Intro
        Semantics
        Using
        Prerequisite Compiler Flags
        Using Parallel Mode
        Using Specific Parallel Components
        Design
        Interface Basics
        Configuration and Tuning
        Implementation Namespaces
        Testing
        Bibliography
        32. Profile Mode
        Intro
        Using the Profile Mode
        Tuning the Profile Mode
        Design
        Wrapper Model
        Instrumentation
        Run Time Behavior
        Analysis and Diagnostics
        Cost Model
        Reports
        Testing
        Extensions for Custom Containers
        Empirical Cost Model
        Implementation Issues
        Stack Traces
        Symbolization of Instruction Addresses
        Concurrency
        Using the Standard Library in the Instrumentation Implementation
        Malloc Hooks
        Construction and Destruction of Global Objects
        Developer Information
        Big Picture
        How To Add A Diagnostic
        Diagnostics
        Diagnostic Template
        Containers
        Algorithms
        Data Locality
        Multithreaded Data Access
        Statistics
        Bibliography
        33. Allocators
        mt_allocator
        Intro
        Design Issues
        Implementation
        Single Thread Example
        Multiple Thread Example
        bitmap_allocator
        Design
        Implementation
        34. Containers
        Policy Based Data Structures
        HP/SGI
        Deprecated HP/SGI
        35. Utilities
        36. Algorithms
        37. Numerics
        38. Iterators
        39. Input and Output
        Derived filebufs
        40. Demangling
        41. Concurrency
        Design
        Interface to Locks and Mutexes
        Interface to Atomic Functions
        Implementation
        Using Builtin Atomic Functions
        Thread Abstraction
        Use
        A. +
        16. Compile Time Checks
        17. Debug Mode
        Intro
        Semantics
        Using
        Using the Debug Mode
        Using a Specific Debug Container
        Design
        Goals
        Methods
        Other Implementations
        18. Parallel Mode
        Intro
        Semantics
        Using
        Prerequisite Compiler Flags
        Using Parallel Mode
        Using Specific Parallel Components
        Design
        Interface Basics
        Configuration and Tuning
        Implementation Namespaces
        Testing
        Bibliography
        19. Profile Mode
        Intro
        Using the Profile Mode
        Tuning the Profile Mode
        Design
        Wrapper Model
        Instrumentation
        Run Time Behavior
        Analysis and Diagnostics
        Cost Model
        Reports
        Testing
        Extensions for Custom Containers
        Empirical Cost Model
        Implementation Issues
        Stack Traces
        Symbolization of Instruction Addresses
        Concurrency
        Using the Standard Library in the Instrumentation Implementation
        Malloc Hooks
        Construction and Destruction of Global Objects
        Developer Information
        Big Picture
        How To Add A Diagnostic
        Diagnostics
        Diagnostic Template
        Containers
        Algorithms
        Data Locality
        Multithreaded Data Access
        Statistics
        Bibliography
        20. Allocators
        mt_allocator
        Intro
        Design Issues
        Implementation
        Single Thread Example
        Multiple Thread Example
        bitmap_allocator
        Design
        Implementation
        21. Containers
        Policy Based Data Structures
        HP/SGI
        Deprecated HP/SGI
        22. Utilities
        23. Algorithms
        24. Numerics
        25. Iterators
        26. Input and Output
        Derived filebufs
        27. Demangling
        28. Concurrency
        Design
        Interface to Locks and Mutexes
        Interface to Atomic Functions
        Implementation
        Using Builtin Atomic Functions
        Thread Abstraction
        Use
        IV. + Appendices +
        A. Contributing -
        Contributor Checklist
        Reading
        Assignment
        Getting Sources
        Submitting Patches
        Directory Layout and Source Conventions
        Coding Style
        Bad Identifiers
        By Example
        Documentation Style
        Doxygen
        Docbook
        Design Notes
        B. +
        Contributor Checklist
        Reading
        Assignment
        Getting Sources
        Submitting Patches
        Directory Layout and Source Conventions
        Coding Style
        Bad Identifiers
        By Example
        Documentation Style
        Doxygen
        Docbook
        Combines
        Design Notes
        B. Porting and Maintenance
        Configure and Build Hacking
        Prerequisites
        Overview: What Comes from Where
        Storing Information in non-AC files (like configure.host)
        Coding and Commenting Conventions
        The acinclude.m4 layout
        GLIBCXX_ENABLE, the --enable maker
        Porting to New Hardware or Operating Systems
        Operating System
        CPU
        Character Types
        Thread Safety
        Numeric Limits
        Libtool
        Test
        Organization
        Running the Testsuite
        Writing a new test case
        Test Harness and Utilities
        Special Topics
        ABI Policy and Guidelines
        The C++ Interface
        Versioning
        Allowed Changes
        Prohibited Changes
        Implementation
        Testing
        Outstanding Issues
        API Evolution and Deprecation History
        3.0
        3.1
        3.2
        3.3
        3.4
        4.0
        4.1
        4.2
        4.3
        4.4
        4.5
        Backwards Compatibility
        First
        Second
        Third
        C. @@ -51,7 +61,7 @@
        D. GNU General Public License version 3 -
        E. GNU Free Documentation License
        Index

        List of Tables

        1.1. C++ 1998/2003 Implementation Status
        1.2. C++ 200x Implementation Status
        1.3. C++ TR1 Implementation Status
        1.4. C++ TR 24733 Implementation Status
        3.1. C++ Command Options
        3.2. C++ 1998 Library Headers
        3.3. C++ 1998 Library Headers for C Library Facilities
        3.4. C++ 200x Library Headers
        3.5. C++ 200x Library Headers for C Library Facilities
        3.6. C++ TR 1 Library Headers
        3.7. C++ TR 1 Library Headers for C Library Facilities
        3.8. C++ TR 24733 Decimal Floating-Point Header
        3.9. C++ ABI Headers
        3.10. Extension Headers
        3.11. Extension Debug Headers
        3.12. Extension Profile Headers
        3.13. Extension Parallel Headers
        30.1. Debugging Containers
        30.2. Debugging Containers C++0x
        31.1. Parallel Algorithms
        32.1. Code Location
        32.2. Diagnostics
        33.1. Bitmap Allocator Memory Map
        A.1. HTML to Doxygen markup comparison
        A.2. HTML to Docbook XML markup comparison
        A.3. Docbook XML Element Use
        B.1. Extension Allocators
        B.2. Extension Allocators Continued
        Prev   Next
        The GNU C++ Library Documentation Home Part I.  +
        E. GNU Free Documentation License

        List of Tables

        1.1. C++ 1998/2003 Implementation Status
        1.2. C++ 200x Implementation Status
        1.3. C++ TR1 Implementation Status
        1.4. C++ TR 24733 Implementation Status
        3.1. C++ Command Options
        3.2. C++ 1998 Library Headers
        3.3. C++ 1998 Library Headers for C Library Facilities
        3.4. C++ 200x Library Headers
        3.5. C++ 200x Library Headers for C Library Facilities
        3.6. C++ TR 1 Library Headers
        3.7. C++ TR 1 Library Headers for C Library Facilities
        3.8. C++ TR 24733 Decimal Floating-Point Header
        3.9. C++ ABI Headers
        3.10. Extension Headers
        3.11. Extension Debug Headers
        3.12. Extension Profile Headers
        3.13. Extension Parallel Headers
        17.1. Debugging Containers
        17.2. Debugging Containers C++0x
        18.1. Parallel Algorithms
        19.1. Profile Code Location
        19.2. Profile Diagnostics
        20.1. Bitmap Allocator Memory Map
        A.1. HTML to Doxygen Markup Comparison
        A.2. HTML to Docbook XML Markup Comparison
        A.3. Docbook XML Element Use
        B.1. Extension Allocators
        B.2. Extension Allocators Continued
        Prev   Next
        The GNU C++ Library Documentation Home Part I.  Introduction
        diff --git a/libstdc++-v3/doc/html/manual/status.html b/libstdc++-v3/doc/html/manual/status.html index be894aa296d..2dd8c691a68 100644 --- a/libstdc++-v3/doc/html/manual/status.html +++ b/libstdc++-v3/doc/html/manual/status.html @@ -8,7 +8,7 @@ This status table is based on the table of contents of ISO/IEC 14882:2003.

        This page describes the C++ support in mainline GCC SVN, not in any particular release. -

        Table 1.1. C++ 1998/2003 Implementation Status

        SectionDescriptionStatusComments
        +

        Table 1.1. C++ 1998/2003 Implementation Status

        SectionDescriptionStatusComments
        18 Language support @@ -58,8 +58,8 @@ particular release. [1.3.5] implementation-defined behavior

        Behavior, for a well-formed program construct and correct data, that - depends on the implementation and that each implementation - shall document. + depends on the implementation and that each implementation + shall document.

        We do so here, for the C++ library only. Behavior of the compiler, linker, runtime loader, and other elements of "the @@ -76,7 +76,7 @@ particular release. [17.4.4.5] Non-reentrant functions are probably best discussed in the various sections on multithreading (see above).

        [18.1]/4 The type of NULL is described - here. + here.

        [18.3]/8 Even though it's listed in the library sections, libstdc++ has zero control over what the cleanup code hands back to the runtime loader. Talk to the compiler people. :-) @@ -90,7 +90,7 @@ particular release. class. But they are the mangled names; you will need to call c++filt and pass the names as command-line parameters to demangle them, or call a - runtime demangler function. + runtime demangler function. (The classes in <stdexcept> have constructors which require an argument to use later for what() calls, so the problem of what()'s value does not arise in most @@ -117,11 +117,11 @@ particular release. here would defeat the purpose. :-)

        [21.1.3.1]/5 I don't really know about the mbstate_t stuff... see - the chapter 22 + the chapter 22 notes for what does exist.

        [22.*] Anything and everything we have on locale implementation will be described - over here. + over here.

        [26.2.8]/9 I have no idea what complex<T>'s pow(0,0) returns.

        [27.4.2.4]/2 Calling @@ -139,11 +139,11 @@ particular release.

        [27.7.1.3]/16, [27.8.1.4]/10 The effects of pubsetbuf/setbuf are described - in this chapter. + in this chapter.

        [27.8.1.4]/16 Calling fstream::sync when a get area exists will... whatever fflush() does, I think.

        C++ 200x

        -This table is based on the table of contents of ISO/IEC +This table is based on the table of contents of ISO/IEC Doc No: N3000=09-0190 Date: 2009-11-09 Working Draft, Standard for Programming Language C++

        @@ -157,7 +157,7 @@ presence of the required flag.

        This page describes the C++0x support in mainline GCC SVN, not in any particular release. -

        Table 1.2. C++ 200x Implementation Status

        SectionDescriptionStatusComments
        +

        Table 1.2. C++ 200x Implementation Status

        SectionDescriptionStatusComments
        18 Language support @@ -173,7 +173,7 @@ particular release.

        Uses code from boost::shared_ptr. -

        +

        20.8.13.3Class template weak_ptrY 
        20.8.13.4Class template owner_lessY 
        20.8.13.5Class template emable_shared_from_thisY 
        20.8.13.6shared_ptr atomic accessPartial 
        20.8.13.7Pointer safetyPartial 
        20.8.14AlignN 
        20.8.15C libraryY 
        20.9Time utilities  
        20.9.1Clock requirementsY 
        20.9.2Time-related traits  
        20.9.2.1treat_as_floating_pointY 
        20.9.2.2duration_valuesPartialMissing constexpr
        20.9.2.3Specializations of common_typeY 
        20.9.3Class template durationPartialMissing constexpr
        20.9.4Class template time_pointPartialMissing constexpr
        20.9.5Clocks  
        20.9.5.1Class system_clockY 
        20.9.5.2Class monotonic_clockY 
        20.9.5.3Class high_resolution_clockY 
        20.10Date and time functionsY 
        21 @@ -229,11 +229,11 @@ In this implementation the header names are prefixed by

        This page describes the TR1 support in mainline GCC SVN, not in any particular release. -

        Table 1.3. C++ TR1 Implementation Status

        SectionDescriptionStatusComments
        2General Utilities
        2.1Reference wrappers  
        2.1.1Additions to header <functional> synopsisY 
        2.1.2Class template reference_wrapper  
        2.1.2.1reference_wrapper construct/copy/destroyY 
        2.1.2.2reference_wrapper assignmentY 
        2.1.2.3reference_wrapper accessY 
        2.1.2.4reference_wrapper invocationY 
        2.1.2.5reference_wrapper helper functionsY 
        2.2Smart pointers  
        2.2.1Additions to header <memory> synopsisY 
        2.2.2Class bad_weak_ptrY 
        2.2.3Class template shared_ptr  +

        Table 1.3. C++ TR1 Implementation Status

        SectionDescriptionStatusComments
        2General Utilities
        2.1Reference wrappers  
        2.1.1Additions to header <functional> synopsisY 
        2.1.2Class template reference_wrapper  
        2.1.2.1reference_wrapper construct/copy/destroyY 
        2.1.2.2reference_wrapper assignmentY 
        2.1.2.3reference_wrapper accessY 
        2.1.2.4reference_wrapper invocationY 
        2.1.2.5reference_wrapper helper functionsY 
        2.2Smart pointers  
        2.2.1Additions to header <memory> synopsisY 
        2.2.2Class bad_weak_ptrY 
        2.2.3Class template shared_ptr 

        Uses code from boost::shared_ptr. -

        +

        2.2.3.1shared_ptr constructorsY 
        2.2.3.2shared_ptr destructorY 
        2.2.3.3shared_ptr assignmentY 
        2.2.3.4shared_ptr modifiersY 
        2.2.3.5shared_ptr observersY 
        2.2.3.6shared_ptr comparisonY 
        2.2.3.7shared_ptr I/OY 
        2.2.3.8shared_ptr specialized algorithmsY 
        2.2.3.9shared_ptr castsY 
        2.2.3.10get_deleterY 
        2.2.4Class template weak_ptr  
        2.2.4.1weak_ptr constructorsY 
        2.2.4.2weak_ptr destructorY 
        2.2.4.3weak_ptr assignmentY 
        2.2.4.4weak_ptr modifiersY 
        2.2.4.5weak_ptr observersY 
        2.2.4.6weak_ptr comparisonY 
        2.2.4.7weak_ptr specialized algorithmsY 
        2.2.5Class template enable_shared_from_thisY 
        3Function Objects
        3.1DefinitionsY 
        3.2Additions to <functional> synopsisY 
        3.3RequirementsY 
        3.4Function return typesY 
        3.5Function template mem_fnY 
        3.6Function object binders  
        3.6.1Class template is_bind_expressionY 
        3.6.2Class template is_placeholderY 
        3.6.3Function template bindY 
        3.6.4PlaceholdersY 
        3.7Polymorphic function wrappers  
        3.7.1Class bad_function_callY 
        3.7.1.1bad_function_call constructorY 
        3.7.2Class template function  
        3.7.2.1function construct/copy/destroyY 
        3.7.2.2function modifiersY 
        3.7.2.3function capacityY 
        3.7.2.4function invocationY 
        3.7.2.5function target accessY 
        3.7.2.6undefined operatorsY 
        3.7.2.7null pointer comparison operatorsY 
        3.7.2.8specialized algorithmsY 
        4Metaprogramming and type traits
        4.1RequirementsY 
        4.2Header <type_traits> synopsisY 
        4.3Helper classesY 
        4.4General RequirementsY 
        4.5Unary Type Traits  
        4.5.1Primary Type CategoriesY 
        4.5.2Composite type traitsY 
        4.5.3Type propertiesY 
        4.6Relationships between typesY 
        4.7Transformations between types  
        4.7.1Const-volatile modificationsY 
        4.7.2Reference modificationsY 
        4.7.3Array modificationsY 
        4.7.4Pointer modificationsY 
        4.8Other transformationsY 
        4.9Implementation requirementsY 
        5Numerical Facilities
        5.1Random number generation  
        5.1.1RequirementsY 
        5.1.2Header <random> synopsisY 
        5.1.3Class template variate_generatorY 
        5.1.4Random number engine class templatesY 
        5.1.4.1Class template linear_congruentialY 
        5.1.4.2Class template mersenne_twisterY 
        5.1.4.3Class template subtract_with_carryY 
        5.1.4.4Class template subtract_with_carry_01Y 
        5.1.4.5Class template discard_blockY 
        5.1.4.6Class template xor_combineYoperator()() per N2079
        5.1.5Engines with predefined parametersY 
        5.1.6Class random_deviceY 
        5.1.7Random distribution class templatesY 
        5.1.7.1Class template uniform_intY 
        5.1.7.2Class bernoulli_distributionY 
        5.1.7.3Class template geometric_distributionY 
        5.1.7.4Class template poisson_distributionY 
        5.1.7.5Class template binomial_distributionY 
        5.1.7.6Class template uniform_realY 
        5.1.7.7Class template exponential_distributionY 
        5.1.7.8Class template normal_distributionY 
        5.1.7.9Class template gamma_distributionY 
        5.2Mathematical special functionsY 
        5.2.1Additions to header <cmath> synopsisY 
        5.2.1.1associated Laguerre polynomialsY 
        5.2.1.2associated Legendre functionsY 
        5.2.1.3beta functionY 
        5.2.1.4(complete) elliptic integral of the first kindY 
        5.2.1.5(complete) elliptic integral of the second kindY 
        5.2.1.6(complete) elliptic integral of the third kindY 
        5.2.1.7confluent hypergeometric functionsY 
        5.2.1.8regular modified cylindrical Bessel functionsY 
        5.2.1.9cylindrical Bessel functions (of the first kind)Y 
        5.2.1.10irregular modified cylindrical Bessel functionsY 
        5.2.1.11cylindrical Neumann functionsY 
        5.2.1.12(incomplete) elliptic integral of the first kindY 
        5.2.1.13(incomplete) elliptic integral of the second kindY 
        5.2.1.14(incomplete) elliptic integral of the third kindY 
        5.2.1.15exponential integralY 
        5.2.1.16Hermite polynomialsY 
        5.2.1.17hypergeometric functionsY 
        5.2.1.18Laguerre polynomialsY 
        5.2.1.19Legendre polynomialsY 
        5.2.1.20Riemann zeta functionY 
        5.2.1.21spherical Bessel functions (of the first kind)Y 
        5.2.1.22spherical associated Legendre functionsY 
        5.2.1.23spherical Neumann functionsY 
        5.2.2Additions to header <math.h> synopsisY 
        6Containers
        6.1Tuple typesY 
        6.1.1Header <tuple> synopsisY 
        6.1.2Additions to header <utility> synopsisY 
        6.1.3Class template tupleY 
        6.1.3.1ConstructionY 
        6.1.3.2Tuple creation functionsY 
        6.1.3.3Tuple helper classesY 
        6.1.3.4Element accessY 
        6.1.3.5Relational operatorsY 
        6.1.4PairsY 
        6.2Fixed size arrayY 
        6.2.1Header <array> synopsisY 
        6.2.2Class template arrayY 
        6.2.2.1array constructors, copy, and assignmentY 
        6.2.2.2array specialized algorithmsY 
        6.2.2.3array sizeY 
        6.2.2.4Zero sized arraysY 
        6.2.2.5Tuple interface to class template arrayY 
        6.3Unordered associative containersY 
        6.3.1Unordered associative container requirementsY 
        6.3.1.1Exception safety guaranteesY 
        6.3.2Additions to header <functional> synopsisY 
        6.3.3Class template hashY 
        6.3.4Unordered associative container classesY 
        6.3.4.1Header <unordered_set> synopsisY 
        6.3.4.2Header <unordered_map> synopsisY 
        6.3.4.3Class template unordered_setY 
        6.3.4.3.1unordered_set constructorsY 
        6.3.4.3.2unordered_set swapY 
        6.3.4.4Class template unordered_mapY 
        6.3.4.4.1unordered_map constructorsY 
        6.3.4.4.2unordered_map element accessY 
        6.3.4.4.3unordered_map swapY 
        6.3.4.5Class template unordered_multisetY 
        6.3.4.5.1unordered_multiset constructorsY 
        6.3.4.5.2unordered_multiset swapY 
        6.3.4.6Class template unordered_multimapY 
        6.3.4.6.1unordered_multimap constructorsY 
        6.3.4.6.2unordered_multimap swapY 
        7Regular Expressions
        7.1DefinitionsN 
        7.2RequirementsN 
        7.3Regular expressions summaryN 
        7.4Header <regex> synopsisN 
        7.5Namespace tr1::regex_constantsN 
        7.5.1Bitmask Type syntax_option_typeN 
        7.5.2Bitmask Type regex_constants::match_flag_typeN 
        7.5.3Implementation defined error_typeN 
        7.6Class regex_errorN 
        7.7Class template regex_traitsN 
        7.8Class template basic_regexN 
        7.8.1basic_regex constantsN 
        7.8.2basic_regex constructorsN 
        7.8.3basic_regex assignN 
        7.8.4basic_regex constant operationsN 
        7.8.5basic_regex localeN 
        7.8.6basic_regex swapN 
        7.8.7basic_regex non-member functionsN 
        7.8.7.1basic_regex non-member swapN 
        7.9Class template sub_matchN 
        7.9.1sub_match membersN 
        7.9.2sub_match non-member operatorsN 
        7.10Class template match_resultsN 
        7.10.1match_results constructorsN 
        7.10.2match_results sizeN 
        7.10.3match_results element accessN 
        7.10.4match_results formattingN 
        7.10.5match_results allocatorN 
        7.10.6match_results swapN 
        7.11Regular expression algorithmsN 
        7.11.1exceptionsN 
        7.11.2regex_matchN 
        7.11.3regex_searchN 
        7.11.4regex_replaceN 
        7.12Regular expression IteratorsN 
        7.12.1Class template regex_iteratorN 
        7.12.1.1regex_iterator constructorsN 
        7.12.1.2regex_iterator comparisonsN 
        7.12.1.3regex_iterator dereferenceN 
        7.12.1.4regex_iterator incrementN 
        7.12.2Class template regex_token_iteratorN 
        7.12.2.1regex_token_iterator constructorsN 
        7.12.2.2regex_token_iterator comparisonsN 
        7.12.2.3regex_token_iterator dereferenceN 
        7.12.2.4regex_token_iterator incrementN 
        7.13Modified ECMAScript regular expression grammarN 
        8C Compatibility
        8.1Additions to header <complex>Y 
        8.1.1SynopsisY 
        8.1.2Function acosY 
        8.1.3Function asinY 
        8.1.4Function atanY 
        8.1.5Function acoshY 
        8.1.6Function asinhY 
        8.1.7Function atanhY 
        8.1.8Function fabsY 
        8.1.9Additional OverloadsY 
        8.2Header <ccomplex>NDR 551
        8.3Header <complex.h>NDR 551
        8.4Additions to header <cctype>Y 
        8.4.1SynopsisY 
        8.4.2Function isblankY 
        8.5Additions to header <ctype.h>Y 
        8.6Header <cfenv>Y 
        8.6.1SynopsisY 
        8.6.2DefinitionsY 
        8.7Header <fenv.h>Y 
        8.8Additions to header <cfloat>Y 
        8.9Additions to header <float.h>Y 
        8.10Additions to header <ios>N 
        8.10.1SynopsisN 
        8.10.2Function hexfloatN 
        8.11Header <cinttypes>Y 
        8.11.1SynopsisYDR 557
        8.11.2DefinitionsY 
        8.12Header <inttypes.h>Y 
        8.13Additions to header <climits>Y 
        8.14Additions to header <limits.h>Y 
        8.15Additions to header <locale>N 
        8.16Additions to header <cmath>Y 
        8.16.1SynopsisY 
        8.16.2DefinitionsY 
        8.16.3Function template definitionsY 
        8.16.4Additional overloadsYDR 568; DR 550
        8.17Additions to header <math.h>Y 
        8.18Additions to header <cstdarg>Y 
        8.19Additions to header <stdarg.h>Y 
        8.20The header <cstdbool>Y 
        8.21The header <stdbool.h>Y 
        8.22The header <cstdint>Y 
        8.22.1SynopsisY 
        8.22.2DefinitionsY 
        8.23The header <stdint.h>Y 
        8.24Additions to header <cstdio>Y 
        8.24.1SynopsisY 
        8.24.2DefinitionsY 
        8.24.3Additional format specifiersYC library dependency
        8.24.4Additions to header <stdio.h>Y 
        8.25Additions to header <cstdlib>Y 
        8.25.1SynopsisY 
        8.25.2DefinitionsY 
        8.25.3Function absY 
        8.25.4Function divY 
        8.26Additions to header <stdlib.h>Y 
        8.27Header <ctgmath>YDR 551
        8.28Header <tgmath.h>YDR 551
        8.29Additions to header <ctime>YC library dependency
        8.30Additions to header <cwchar>Y 
        8.30.1SynopsisY 
        8.30.2DefinitionsY 
        8.30.3Additional wide format specifiersYC library dependency
        8.31Additions to header <wchar.h>Y 
        8.32Additions to header <cwctype>Y 
        8.32.1SynopsisY 
        8.32.2Function iswblankY 
        8.33Additions to header <wctype.h>Y 

        C++ TR 24733

        This table is based on the table of contents of ISO/IEC TR 24733 Date: 2009-08-28 @@ -242,7 +242,7 @@ decimal floating-point arithmetic

        This page describes the TR 24733 support in mainline GCC SVN, not in any particular release. -

        Table 1.4. C++ TR 24733 Implementation Status

        SectionDescriptionStatusComments
        +

        Table 1.4. C++ TR 24733 Implementation Status

        SectionDescriptionStatusComments
        0 Introduction diff --git a/libstdc++-v3/doc/html/manual/bk01pt11ch25s02.html b/libstdc++-v3/doc/html/manual/streambufs.html similarity index 51% rename from libstdc++-v3/doc/html/manual/bk01pt11ch25s02.html rename to libstdc++-v3/doc/html/manual/streambufs.html index b713ad2ef02..277339d6e27 100644 --- a/libstdc++-v3/doc/html/manual/bk01pt11ch25s02.html +++ b/libstdc++-v3/doc/html/manual/streambufs.html @@ -1,6 +1,63 @@ -Buffering
        Buffering
        Prev Chapter 25. Stream Buffers Next

        Buffering

        First, are you sure that you understand buffering? Particularly +Stream Buffers

        Stream Buffers
        Prev Chapter 13.  + Input and Output + + Next

        Stream Buffers

        Derived streambuf Classes

        +

        Creating your own stream buffers for I/O can be remarkably easy. + If you are interested in doing so, we highly recommend two very + excellent books: + Standard C++ + IOStreams and Locales by Langer and Kreft, ISBN 0-201-18395-1, and + The C++ Standard Library + by Nicolai Josuttis, ISBN 0-201-37926-0. Both are published by + Addison-Wesley, who isn't paying us a cent for saying that, honest. +

        Here is a simple example, io/outbuf1, from the Josuttis text. It + transforms everything sent through it to uppercase. This version + assumes many things about the nature of the character type being + used (for more information, read the books or the newsgroups): + 

        +    #include <iostream>
+    #include <streambuf>
+    #include <locale>
+    #include <cstdio>
+
+    class outbuf : public std::streambuf
+    {
+      protected:
+	/* central output function
+	 * - print characters in uppercase mode
+	 */
+	virtual int_type overflow (int_type c) {
+	    if (c != EOF) {
+		// convert lowercase to uppercase
+		c = std::toupper(static_cast<char>(c),getloc());
+
+		// and write the character to the standard output
+		if (putchar(c) == EOF) {
+		    return EOF;
+		}
+	    }
+	    return c;
+	}
+    };
+
+    int main()
+    {
+	// create special output buffer
+	outbuf ob;
+	// initialize output stream with that output buffer
+	std::ostream out(&ob);
+
+	out << "31 hexadecimal: "
+	    << std::hex << 31 << std::endl;
+	return 0;
+    }
+

        Try it yourself! More examples can be found in 3.1.x code, in + include/ext/*_filebuf.h, and in this article by James Kanze: + Filtering + Streambufs. +

        Buffering

        First, are you sure that you understand buffering? Chaptericularly the fact that C++ may not, in fact, have anything to do with it?

        The rules for buffering can be a little odd, but they aren't any different from those of C. (Maybe that's why they can be a bit @@ -25,8 +82,8 @@ If you need a newline, just write a newline: 

            output << "a line of text\n"
-          << some_data_variable << '\n'
-          << "another line of text\n";

        I have also joined the output statements into a single statement. + << some_data_variable << '\n' + << "another line of text\n";

        I have also joined the output statements into a single statement. You could make the code prettier by moving the single newline to the start of the quoted text on the last line, for example.

        If you do need to flush the buffer above, you can send an @@ -35,7 +92,7 @@ 

            output << ...... << flush;    // can use std::flush manipulator
    output.flush();               // or call a member fn

        On the other hand, there are times when writing to a file should - be like writing to standard error; no buffering should be done + be like writing to standard error; no buffering should be done because the data needs to appear quickly (a prime example is a log file for security-related information). The way to do this is just to turn off the buffering before any I/O operations at @@ -54,13 +111,13 @@ os << "this data is written immediately\n"; is >> i; // and this will probably cause a disk read

        Since all aspects of buffering are handled by a streambuf-derived member, it is necessary to get at that member with rdbuf(). - Then the public version of setbuf can be called. The + Then the public version of setbuf can be called. The arguments are the same as those for the Standard C I/O Library function (a buffer area followed by its size).

        A great deal of this is implementation-dependent. For example, - streambuf does not specify any actions for its own + streambuf does not specify any actions for its own setbuf()-ish functions; the classes derived from - streambuf each define behavior that "makes + streambuf each define behavior that "makes sense" for that class: an argument of (0,0) turns off buffering for filebuf but does nothing at all for its siblings stringbuf and strstreambuf, and specifying @@ -74,4 +131,7 @@ just those at the language/library level. Kernel buffers, disk buffers, and the like will also have an effect. Inspecting and changing those are system-dependent. -

        Prev Up Next
        Chapter 25. Stream Buffers Home Chapter 26. Memory Based Streams
        +

        Prev Up Next
        Chapter 13.  + Input and Output + + Home Memory Based Streams
        diff --git a/libstdc++-v3/doc/html/manual/strings.html b/libstdc++-v3/doc/html/manual/strings.html dissimilarity index 85% index 76fba6ee433..d1dfd3b2f71 100644 --- a/libstdc++-v3/doc/html/manual/strings.html +++ b/libstdc++-v3/doc/html/manual/strings.html @@ -1,9 +1,366 @@ - - -Part V.  Strings
        Part V.  - Strings - -
        Prev The GNU C++ Library Next

        Part V.  - Strings - -

        Table of Contents

        13. String Classes
        Simple Transformations
        Case Sensitivity
        Arbitrary Character Types
        Tokenizing
        Shrink to Fit
        CString (MFC)
        Prev Up Next
        shared_ptr Home Chapter 13. String Classes
        + + +Chapter 7.  Strings
        Chapter 7.  + Strings + +
        Prev Part II.  + Standard Contents + Next

        Chapter 7.  + Strings + +

        Table of Contents

        String Classes
        Simple Transformations
        Case Sensitivity
        Arbitrary Character Types
        Tokenizing
        Shrink to Fit
        CString (MFC)

        String Classes

        Simple Transformations

        + Here are Standard, simple, and portable ways to perform common + transformations on a string instance, such as + "convert to all upper case." The word transformations + is especially apt, because the standard template function + transform<> is used. +

        + This code will go through some iterations. Here's a simple + version: + 

        +   #include <string>
+   #include <algorithm>
+   #include <cctype>      // old <ctype.h>
+
+   struct ToLower
+   {
+     char operator() (char c) const  { return std::tolower(c); }
+   };
+
+   struct ToUpper
+   {
+     char operator() (char c) const  { return std::toupper(c); }
+   };
+
+   int main()
+   {
+     std::string  s ("Some Kind Of Initial Input Goes Here");
+
+     // Change everything into upper case
+     std::transform (s.begin(), s.end(), s.begin(), ToUpper());
+
+     // Change everything into lower case
+     std::transform (s.begin(), s.end(), s.begin(), ToLower());
+
+     // Change everything back into upper case, but store the
+     // result in a different string
+     std::string  capital_s;
+     capital_s.resize(s.size());
+     std::transform (s.begin(), s.end(), capital_s.begin(), ToUpper());
+   }
+

        + Note that these calls all + involve the global C locale through the use of the C functions + toupper/tolower. This is absolutely guaranteed to work -- + but only if the string contains only characters + from the basic source character set, and there are only + 96 of those. Which means that not even all English text can be + represented (certain British spellings, proper names, and so forth). + So, if all your input forevermore consists of only those 96 + characters (hahahahahaha), then you're done. +

        Note that the + ToUpper and ToLower function objects + are needed because toupper and tolower + are overloaded names (declared in <cctype> and + <locale>) so the template-arguments for + transform<> cannot be deduced, as explained in + this + message. + + At minimum, you can write short wrappers like + 

        +   char toLower (char c)
+   {
+      return std::tolower(c);
+   }

        (Thanks to James Kanze for assistance and suggestions on all of this.) +

        Another common operation is trimming off excess whitespace. Much + like transformations, this task is trivial with the use of string's + find family. These examples are broken into multiple + statements for readability: + 

        +   std::string  str (" \t blah blah blah    \n ");
+
+   // trim leading whitespace
+   string::size_type  notwhite = str.find_first_not_of(" \t\n");
+   str.erase(0,notwhite);
+
+   // trim trailing whitespace
+   notwhite = str.find_last_not_of(" \t\n");
+   str.erase(notwhite+1);

        Obviously, the calls to find could be inserted directly + into the calls to erase, in case your compiler does not + optimize named temporaries out of existence. +

        Case Sensitivity

        +

        The well-known-and-if-it-isn't-well-known-it-ought-to-be + Guru of the Week + discussions held on Usenet covered this topic in January of 1998. + Briefly, the challenge was, “write a 'ci_string' class which + is identical to the standard 'string' class, but is + case-insensitive in the same way as the (common but nonstandard) + C function stricmp()”. + 

        +   ci_string s( "AbCdE" );
+
+   // case insensitive
+   assert( s == "abcde" );
+   assert( s == "ABCDE" );
+
+   // still case-preserving, of course
+   assert( strcmp( s.c_str(), "AbCdE" ) == 0 );
+   assert( strcmp( s.c_str(), "abcde" ) != 0 );

        The solution is surprisingly easy. The original answer was + posted on Usenet, and a revised version appears in Herb Sutter's + book Exceptional C++ and on his website as GotW 29. +

        See? Told you it was easy!

        + Added June 2000: The May 2000 issue of C++ + Report contains a fascinating article by + Matt Austern (yes, the Matt Austern) on why + case-insensitive comparisons are not as easy as they seem, and + why creating a class is the wrong way to go + about it in production code. (The GotW answer mentions one of + the principle difficulties; his article mentions more.) +

        Basically, this is "easy" only if you ignore some things, + things which may be too important to your program to ignore. (I chose + to ignore them when originally writing this entry, and am surprised + that nobody ever called me on it...) The GotW question and answer + remain useful instructional tools, however. +

        Added September 2000: James Kanze provided a link to a + Unicode + Technical Report discussing case handling, which provides some + very good information. +

        Arbitrary Character Types

        +

        The std::basic_string is tantalizingly general, in that + it is parameterized on the type of the characters which it holds. + In theory, you could whip up a Unicode character class and instantiate + std::basic_string<my_unicode_char>, or assuming + that integers are wider than characters on your platform, maybe just + declare variables of type std::basic_string<int>. +

        That's the theory. Remember however that basic_string has additional + type parameters, which take default arguments based on the character + type (called CharT here): + 

        +      template <typename CharT,
+		typename Traits = char_traits<CharT>,
+		typename Alloc = allocator<CharT> >
+      class basic_string { .... };

        Now, allocator<CharT> will probably Do The Right + Thing by default, unless you need to implement your own allocator + for your characters. +

        But char_traits takes more work. The char_traits + template is declared but not defined. + That means there is only + 

        +      template <typename CharT>
+	struct char_traits
+	{
+	    static void foo (type1 x, type2 y);
+	    ...
+	};

        and functions such as char_traits<CharT>::foo() are not + actually defined anywhere for the general case. The C++ standard + permits this, because writing such a definition to fit all possible + CharT's cannot be done. +

        The C++ standard also requires that char_traits be specialized for + instantiations of char and wchar_t, and it + is these template specializations that permit entities like + basic_string<char,char_traits<char>> to work. +

        If you want to use character types other than char and wchar_t, + such as unsigned char and int, you will + need suitable specializations for them. For a time, in earlier + versions of GCC, there was a mostly-correct implementation that + let programmers be lazy but it broke under many situations, so it + was removed. GCC 3.4 introduced a new implementation that mostly + works and can be specialized even for int and other + built-in types. +

        If you want to use your own special character class, then you have + a lot + of work to do, especially if you with to use i18n features + (facets require traits information but don't have a traits argument). +

        Another example of how to specialize char_traits was given on the + mailing list and at a later date was put into the file + include/ext/pod_char_traits.h. We agree + that the way it's used with basic_string (scroll down to main()) + doesn't look nice, but that's because the + nice-looking first attempt turned out to not + be conforming C++, due to the rule that CharT must be a POD. + (See how tricky this is?) +

        Tokenizing

        +

        The Standard C (and C++) function strtok() leaves a lot to + be desired in terms of user-friendliness. It's unintuitive, it + destroys the character string on which it operates, and it requires + you to handle all the memory problems. But it does let the client + code decide what to use to break the string into pieces; it allows + you to choose the "whitespace," so to speak. +

        A C++ implementation lets us keep the good things and fix those + annoyances. The implementation here is more intuitive (you only + call it once, not in a loop with varying argument), it does not + affect the original string at all, and all the memory allocation + is handled for you. +

        It's called stringtok, and it's a template function. Sources are + as below, in a less-portable form than it could be, to keep this + example simple (for example, see the comments on what kind of + string it will accept). + 

        +#include <string>
+template <typename Container>
+void
+stringtok(Container &container, string const &in,
+	  const char * const delimiters = " \t\n")
+{
+    const string::size_type len = in.length();
+	  string::size_type i = 0;
+
+    while (i < len)
+    {
+	// Eat leading whitespace
+	i = in.find_first_not_of(delimiters, i);
+	if (i == string::npos)
+	  return;   // Nothing left but white space
+
+	// Find the end of the token
+	string::size_type j = in.find_first_of(delimiters, i);
+
+	// Push token
+	if (j == string::npos)
+	{
+	  container.push_back(in.substr(i));
+	  return;
+	}
+	else
+	  container.push_back(in.substr(i, j-i));
+
+	// Set up for next loop
+	i = j + 1;
+    }
+}
+

        + The author uses a more general (but less readable) form of it for + parsing command strings and the like. If you compiled and ran this + code using it: + 

        +   std::list<string>  ls;
+   stringtok (ls, " this  \t is\t\n  a test  ");
+   for (std::list<string>const_iterator i = ls.begin();
+	i != ls.end(); ++i)
+   {
+       std::cerr << ':' << (*i) << ":\n";
+   }

        You would see this as output: + 

        +   :this:
+   :is:
+   :a:
+   :test:

        with all the whitespace removed. The original s is still + available for use, ls will clean up after itself, and + ls.size() will return how many tokens there were. +

        As always, there is a price paid here, in that stringtok is not + as fast as strtok. The other benefits usually outweigh that, however. +

        Added February 2001: Mark Wilden pointed out that the + standard std::getline() function can be used with standard + istringstreams to perform + tokenizing as well. Build an istringstream from the input text, + and then use std::getline with varying delimiters (the three-argument + signature) to extract tokens into a string. +

        Shrink to Fit

        +

        From GCC 3.4 calling s.reserve(res) on a + string s with res < s.capacity() will + reduce the string's capacity to std::max(s.size(), res). +

        This behaviour is suggested, but not required by the standard. Prior + to GCC 3.4 the following alternative can be used instead + 

        +      std::string(str.data(), str.size()).swap(str);
+

        This is similar to the idiom for reducing + a vector's memory usage + (see this FAQ + entry) but the regular copy constructor cannot be used + because libstdc++'s string is Copy-On-Write. +

        In C++0x mode you can call + s.shrink_to_fit() to achieve the same effect as + s.reserve(s.size()). +

        CString (MFC)

        +

        A common lament seen in various newsgroups deals with the Standard + string class as opposed to the Microsoft Foundation Class called + CString. Often programmers realize that a standard portable + answer is better than a proprietary nonportable one, but in porting + their application from a Win32 platform, they discover that they + are relying on special functions offered by the CString class. +

        Things are not as bad as they seem. In + this + message, Joe Buck points out a few very important things: +

        • The Standard string supports all the operations + that CString does, with three exceptions. +

        • Two of those exceptions (whitespace trimming and case + conversion) are trivial to implement. In fact, we do so + on this page. +

        • The third is CString::Format, which allows formatting + in the style of sprintf. This deserves some mention: +

        + The old libg++ library had a function called form(), which did much + the same thing. But for a Standard solution, you should use the + stringstream classes. These are the bridge between the iostream + hierarchy and the string class, and they operate with regular + streams seamlessly because they inherit from the iostream + hierarchy. An quick example: + 

        +   #include <iostream>
+   #include <string>
+   #include <sstream>
+
+   string f (string& incoming)     // incoming is "foo  N"
+   {
+       istringstream   incoming_stream(incoming);
+       string          the_word;
+       int             the_number;
+
+       incoming_stream >> the_word        // extract "foo"
+		       >> the_number;     // extract N
+
+       ostringstream   output_stream;
+       output_stream << "The word was " << the_word
+		     << " and 3*N was " << (3*the_number);
+
+       return output_stream.str();
+   }

        A serious problem with CString is a design bug in its memory + allocation. Specifically, quoting from that same message: + 

        +   CString suffers from a common programming error that results in
+   poor performance.  Consider the following code:
+
+   CString n_copies_of (const CString& foo, unsigned n)
+   {
+	   CString tmp;
+	   for (unsigned i = 0; i < n; i++)
+		   tmp += foo;
+	   return tmp;
+   }
+
+   This function is O(n^2), not O(n).  The reason is that each +=
+   causes a reallocation and copy of the existing string.  Microsoft
+   applications are full of this kind of thing (quadratic performance
+   on tasks that can be done in linear time) -- on the other hand,
+   we should be thankful, as it's created such a big market for high-end
+   ix86 hardware. :-)
+
+   If you replace CString with string in the above function, the
+   performance is O(n).
+

        Joe Buck also pointed out some other things to keep in mind when + comparing CString and the Standard string class: +

        • CString permits access to its internal representation; coders + who exploited that may have problems moving to string. +

        • Microsoft ships the source to CString (in the files + MFC\SRC\Str{core,ex}.cpp), so you could fix the allocation + bug and rebuild your MFC libraries. + Note: It looks like the CString shipped + with VC++6.0 has fixed this, although it may in fact have been + one of the VC++ SPs that did it. +

        • string operations like this have O(n) complexity + if the implementors do it correctly. The libstdc++ + implementors did it correctly. Other vendors might not. +

        • While chapters of the SGI STL are used in libstdc++, their + string class is not. The SGI string is essentially + vector<char> and does not do any reference + counting like libstdc++'s does. (It is O(n), though.) + So if you're thinking about SGI's string or rope classes, + you're now looking at four possibilities: CString, the + libstdc++ string, the SGI string, and the SGI rope, and this + is all before any allocator or traits customizations! (More + choices than you can shake a stick at -- want fries with that?) +

        Prev Up Next
        Traits Home Chapter 8.  + Localization + +
        diff --git a/libstdc++-v3/doc/html/manual/stringstreams.html b/libstdc++-v3/doc/html/manual/stringstreams.html index 718965570e4..6e6b77eb4e8 100644 --- a/libstdc++-v3/doc/html/manual/stringstreams.html +++ b/libstdc++-v3/doc/html/manual/stringstreams.html @@ -1,14 +1,14 @@ -Chapter 26. Memory Based Streams
        Chapter 26. Memory Based Streams
        Prev Part XI.  +Memory Based Streams
        Memory Based Streams
        Prev Chapter 13.  Input and Output - Next

        Chapter 26. Memory Based Streams

        Table of Contents

        Compatibility With strstream

        Compatibility With strstream

        +

        		 Next

        Memory Based Streams

        Compatibility With strstream

        Stringstreams (defined in the header <sstream>) are in this author's opinion one of the coolest things since sliced time. An example of their use is in the Received Wisdom - section for Chapter 21 (Strings), - describing how to + section for Sect1 21 (Strings), + describing how to format strings.

        The quick definition is: they are siblings of ifstream and ofstream, and they do for std::string what their siblings do for @@ -34,4 +34,4 @@ memory yourself. The strstreams have been officially deprecated, which means that 1) future revisions of the C++ Standard won't support them, and 2) if you use them, people will laugh at you. -

        Prev Up Next
        Buffering Home Chapter 27. File Based Streams
        +

        Prev Up Next
        Stream Buffers Home File Based Streams
        diff --git a/libstdc++-v3/doc/html/manual/support.html b/libstdc++-v3/doc/html/manual/support.html dissimilarity index 88% index 14154ee4622..de3237b4b76 100644 --- a/libstdc++-v3/doc/html/manual/support.html +++ b/libstdc++-v3/doc/html/manual/support.html @@ -1,9 +1,130 @@ - - -Part II.  Support
        Part II.  - Support - -
        Prev The GNU C++ Library Next

        Part II.  - Support - -

        Table of Contents

        4. Types
        Fundamental Types
        Numeric Properties
        NULL
        5. Dynamic Memory
        6. Termination
        Termination Handlers
        Verbose Terminate Handler
        Prev Up Next
        Debugging Support Home 
        + + +Chapter 4.  Support
        Chapter 4.  + Support + +
        Prev Part II.  + Standard Contents + Next

        Chapter 4.  + Support + +

        Table of Contents

        Types
        Fundamental Types
        Numeric Properties
        NULL
        Dynamic Memory
        Termination
        Termination Handlers
        Verbose Terminate Handler

        + This part deals with the functions called and objects created + automatically during the course of a program's existence. +

        + While we can't reproduce the contents of the Standard here (you + need to get your own copy from your nation's member body; see our + homepage for help), we can mention a couple of changes in what + kind of support a C++ program gets from the Standard Library. +

        Types

        Fundamental Types

        + C++ has the following builtin types: +

        • + char +

        • + signed char +

        • + unsigned char +

        • + signed short +

        • + signed int +

        • + signed long +

        • + unsigned short +

        • + unsigned int +

        • + unsigned long +

        • + bool +

        • + wchar_t +

        • + float +

        • + double +

        • + long double +

        + These fundamental types are always available, without having to + include a header file. These types are exactly the same in + either C++ or in C. +

        + Specializing parts of the library on these types is prohibited: + instead, use a POD. +

        Numeric Properties

        + The header limits defines + traits classes to give access to various implementation + defined-aspects of the fundamental types. The traits classes -- + fourteen in total -- are all specializations of the template class + numeric_limits, documented here + and defined as follows: + 

        +   template<typename T>
+     struct class
+     {
+       static const bool is_specialized;
+       static T max() throw();
+       static T min() throw();
+
+       static const int digits;
+       static const int digits10;
+       static const bool is_signed;
+       static const bool is_integer;
+       static const bool is_exact;
+       static const int radix;
+       static T epsilon() throw();
+       static T round_error() throw();
+
+       static const int min_exponent;
+       static const int min_exponent10;
+       static const int max_exponent;
+       static const int max_exponent10;
+
+       static const bool has_infinity;
+       static const bool has_quiet_NaN;
+       static const bool has_signaling_NaN;
+       static const float_denorm_style has_denorm;
+       static const bool has_denorm_loss;
+       static T infinity() throw();
+       static T quiet_NaN() throw();
+       static T denorm_min() throw();
+
+       static const bool is_iec559;
+       static const bool is_bounded;
+       static const bool is_modulo;
+
+       static const bool traps;
+       static const bool tinyness_before;
+       static const float_round_style round_style;
+     };
+

        NULL

        + The only change that might affect people is the type of + NULL: while it is required to be a macro, + the definition of that macro is not allowed + to be (void*)0, which is often used in C. +

        + For g++, NULL is + 

        #define

        'd to be + __null, a magic keyword extension of + g++. +

        + The biggest problem of #defining NULL to be + something like “0L” is that the compiler will view + that as a long integer before it views it as a pointer, so + overloading won't do what you expect. (This is why + g++ has a magic extension, so that + NULL is always a pointer.) +

        In his book Effective + C++, Scott Meyers points out that the best way + to solve this problem is to not overload on pointer-vs-integer + types to begin with. He also offers a way to make your own magic + NULL that will match pointers before it + matches integers. +

        See + the + Effective C++ CD example +

        Prev Up Next
        Part II.  + Standard Contents + Home Dynamic Memory
        diff --git a/libstdc++-v3/doc/html/manual/termination.html b/libstdc++-v3/doc/html/manual/termination.html dissimilarity index 60% index ff86016f613..ab0bf5e19b6 100644 --- a/libstdc++-v3/doc/html/manual/termination.html +++ b/libstdc++-v3/doc/html/manual/termination.html @@ -1,48 +1,124 @@ - - -Chapter 6. Termination
        Chapter 6. Termination
        Prev Part II.  - Support - - Next

        Chapter 6. Termination

        Table of Contents

        Termination Handlers
        Verbose Terminate Handler

        Termination Handlers

        - Not many changes here to cstdlib. You should note that the - abort() function does not call the - destructors of automatic nor static objects, so if you're - depending on those to do cleanup, it isn't going to happen. - (The functions registered with atexit() - don't get called either, so you can forget about that - possibility, too.) -

        - The good old exit() function can be a bit - funky, too, until you look closer. Basically, three points to - remember are: -

        1. - Static objects are destroyed in reverse order of their creation. -

        2. - Functions registered with atexit() are called in - reverse order of registration, once per registration call. - (This isn't actually new.) -

        3. - The previous two actions are “interleaved,” that is, - given this pseudocode: - 

          -  extern "C or C++" void  f1 (void);
-  extern "C or C++" void  f2 (void);
-  
-  static Thing obj1;
-  atexit(f1);
-  static Thing obj2;
-  atexit(f2);
-

          - then at a call of exit(), - f2 will be called, then - obj2 will be destroyed, then - f1 will be called, and finally - obj1 will be destroyed. If - f1 or f2 allow an - exception to propagate out of them, Bad Things happen. -

        - Note also that atexit() is only required to store 32 - functions, and the compiler/library might already be using some of - those slots. If you think you may run out, we recommend using - the xatexit/xexit combination from libiberty, which has no such limit. -

        Prev Up Next
        Chapter 5. Dynamic Memory Home Verbose Terminate Handler
        + + +Termination
        Termination
        Prev Chapter 4.  + Support + + Next

        Termination

        Termination Handlers

        + Not many changes here to cstdlib. You should note that the + abort() function does not call the + destructors of automatic nor static objects, so if you're + depending on those to do cleanup, it isn't going to happen. + (The functions registered with atexit() + don't get called either, so you can forget about that + possibility, too.) +

        + The good old exit() function can be a bit + funky, too, until you look closer. Basically, three points to + remember are: +

        1. + Static objects are destroyed in reverse order of their creation. +

        2. + Functions registered with atexit() are called in + reverse order of registration, once per registration call. + (This isn't actually new.) +

        3. + The previous two actions are “interleaved,” that is, + given this pseudocode: + 

          +  extern "C or C++" void  f1 (void);
+  extern "C or C++" void  f2 (void);
+
+  static Thing obj1;
+  atexit(f1);
+  static Thing obj2;
+  atexit(f2);
+

          + then at a call of exit(), + f2 will be called, then + obj2 will be destroyed, then + f1 will be called, and finally + obj1 will be destroyed. If + f1 or f2 allow an + exception to propagate out of them, Bad Things happen. +

        + Note also that atexit() is only required to store 32 + functions, and the compiler/library might already be using some of + those slots. If you think you may run out, we recommend using + the xatexit/xexit combination from libiberty, which has no such limit. +

        Verbose Terminate Handler

        + If you are having difficulty with uncaught exceptions and want a + little bit of help debugging the causes of the core dumps, you can + make use of a GNU extension, the verbose terminate handler. + 

        +#include <exception>
+
+int main()
+{
+  std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+  ...
+
+  throw anything;
+}
+

        + The __verbose_terminate_handler function + obtains the name of the current exception, attempts to demangle + it, and prints it to stderr. If the exception is derived from + exception then the output from + what() will be included. +

        + Any replacement termination function is required to kill the + program without returning; this one calls abort. +

        + For example: + 

        +#include <exception>
+#include <stdexcept>
+
+struct argument_error : public std::runtime_error
+{
+  argument_error(const std::string& s): std::runtime_error(s) { }
+};
+
+int main(int argc)
+{
+  std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
+  if (argc > 5)
+    throw argument_error(“argc is greater than 5!”);
+  else
+    throw argc;
+}
+

        + With the verbose terminate handler active, this gives: + 

        +   
+   % ./a.out
+   terminate called after throwing a `int'
+   Aborted
+   % ./a.out f f f f f f f f f f f
+   terminate called after throwing an instance of `argument_error'
+   what(): argc is greater than 5!
+   Aborted
+   
+

        + The 'Aborted' line comes from the call to + abort(), of course. +

        + This is the default termination handler; nothing need be done to + use it. To go back to the previous “silent death” + method, simply include exception and + cstdlib, and call + 

        +     std::set_terminate(std::abort);
+

        + After this, all calls to terminate will use + abort as the terminate handler. +

        + Note: the verbose terminate handler will attempt to write to + stderr. If your application closes stderr or redirects it to an + inappropriate location, + __verbose_terminate_handler will behave in + an unspecified manner. +

        Prev Up Next
        Dynamic Memory Home Chapter 5.  + Diagnostics + +
        diff --git a/libstdc++-v3/doc/html/manual/test.html b/libstdc++-v3/doc/html/manual/test.html index c5bcc1f54c3..9065845c34c 100644 --- a/libstdc++-v3/doc/html/manual/test.html +++ b/libstdc++-v3/doc/html/manual/test.html @@ -278,7 +278,7 @@ runtest --tool libstdc++ --srcdir=/path/to/gcc/libstdc++-v3/testsuite please email the main libstdc++ mailing list if you see something odd or have questions.

        Permutations

        - To run the libstdc++ test suite under the debug mode, edit + To run the libstdc++ test suite under the debug mode, edit libstdc++-v3/scripts/testsuite_flags to add the compile-time flag -D_GLIBCXX_DEBUG to the result printed by the --build-cxx @@ -289,7 +289,7 @@ runtest --tool libstdc++ --srcdir=/path/to/gcc/libstdc++-v3/testsuite release mode: any deviation indicates an error in either the library or the test suite.

        - The parallel + The parallel mode can be tested in much the same manner, substituting -D_GLIBCXX_PARALLEL for -D_GLIBCXX_DEBUG in the previous paragraph. @@ -493,7 +493,7 @@ only default variables. reporting functions including:

        • time_counter

        • resource_counter

        • report_performance

        Special Topics

        Qualifying Exception Safety Guarantees - +

        Overview

        Testing is composed of running a particular test sequence, and looking at what happens to the surrounding code when @@ -508,7 +508,7 @@ only default variables. consistency/coherency of the test subject in the event of a thrown exception.

        - Random code paths can be constructed using the the basic test + Random code paths can be constructed using the basic test sequences and instrumentation as above, only combined in a random or pseudo-random way.

        To compute the code paths that throw, test instruments @@ -543,7 +543,7 @@ only default variables. Which has several tests for container member functions, Includes control and test container objects. Configuration includes random seed, iterations, number of distinct values, and the -probability that and exception will be thrown. Assumes instantiating +probability that an exception will be thrown. Assumes instantiating container uses an extension allocator, __gnu_cxx::throw_allocator_random, as the allocator type. diff --git a/libstdc++-v3/doc/html/manual/traits.html b/libstdc++-v3/doc/html/manual/traits.html dissimilarity index 74% index 1d1e6fb75bf..62356dec625 100644 --- a/libstdc++-v3/doc/html/manual/traits.html +++ b/libstdc++-v3/doc/html/manual/traits.html @@ -1,10 +1,10 @@ - - -Chapter 12. Traits

        Chapter 12. Traits
        Prev Part IV.  - Utilities - - Next

        Chapter 12. Traits

        -

        Prev Up Next
        shared_ptr Home Part V.  - Strings - -
        + + +Traits
        Traits
        Prev Chapter 6.  + Utilities + + Next

        Traits

        +

        Prev Up Next
        Memory Home Chapter 7.  + Strings + +
        diff --git a/libstdc++-v3/doc/html/manual/using.html b/libstdc++-v3/doc/html/manual/using.html index 93114db3d57..51dd333bab4 100644 --- a/libstdc++-v3/doc/html/manual/using.html +++ b/libstdc++-v3/doc/html/manual/using.html @@ -11,5 +11,5 @@ enumerated and detailed in the table below.

        By default, g++ is equivalent to g++ -std=gnu++98. The standard library also defaults to this dialect. -

        Table 3.1. C++ Command Options

        Option FlagsDescription
        -std=c++98Use the 1998 ISO C++ standard plus amendments.
        -std=gnu++98As directly above, with GNU extensions.
        -std=c++0xUse the working draft of the upcoming ISO C++0x standard.
        -std=gnu++0xAs directly above, with GNU extensions.
        -fexceptionsSee exception-free dialect
        -frttiAs above, but RTTI-free dialect.
        -pthread or -pthreadsFor ISO C++0x <thread>, <future>, - <mutex>, or <condition_variable>.
        -fopenmpFor parallel mode.

        Prev Up Next
        Make Home Headers
        +

        Table 3.1. C++ Command Options

        Option FlagsDescription
        -std=c++98Use the 1998 ISO C++ standard plus amendments.
        -std=gnu++98As directly above, with GNU extensions.
        -std=c++0xUse the working draft of the upcoming ISO C++0x standard.
        -std=gnu++0xAs directly above, with GNU extensions.
        -fexceptionsSee exception-free dialect
        -frttiAs above, but RTTI-free dialect.
        -pthread or -pthreadsFor ISO C++0x <thread>, <future>, + <mutex>, or <condition_variable>.
        -fopenmpFor parallel mode.

        Prev Up Next
        Make Home Headers
        diff --git a/libstdc++-v3/doc/html/manual/using_concurrency.html b/libstdc++-v3/doc/html/manual/using_concurrency.html index f0f63a9eee2..f18aec31d8f 100644 --- a/libstdc++-v3/doc/html/manual/using_concurrency.html +++ b/libstdc++-v3/doc/html/manual/using_concurrency.html @@ -200,6 +200,6 @@ gcc version 4.1.2 20070925 (Red Hat 4.1.2-33) this at application run-time see here. Also useful are details - on allocator + on allocator options and capabilities.

        Prev Up Next
        Linking Home Exceptions
        diff --git a/libstdc++-v3/doc/html/manual/using_dynamic_or_shared.html b/libstdc++-v3/doc/html/manual/using_dynamic_or_shared.html index 9e48296929a..38e19313029 100644 --- a/libstdc++-v3/doc/html/manual/using_dynamic_or_shared.html +++ b/libstdc++-v3/doc/html/manual/using_dynamic_or_shared.html @@ -21,7 +21,7 @@

      • typeinfo

        • - In addition, throw in + In addition, throw in

        • cxxabi.h.

        @@ -76,13 +76,27 @@ A quick read of the relevant part of the GCC the linker. The exact format of the options is dependent on which linker you use:

        • - GNU ld (default on Linux):-Wl,--rpath,destdir/lib + GNU ld (default on Linux): + -Wl,-rpath,destdir/lib

        • - IRIX ld: - -Wl,-rpath,destdir/lib + IRIX ld: + -Wl,-rpath,destdir/lib

        • - Solaris ld:-Wl,-Rdestdir/lib -

        + Solaris ld: + -Wl,-Rdestdir/lib +

      • + Some linkers allow you to specify the path to the library by + setting LD_RUN_PATH in your environment + when linking. +

      • + On some platforms the system administrator can configure the + dynamic linker to always look for libraries in + destdir/lib, for example + by using the ldconfig utility on Linux + or the crle utility on Solaris. This is a + system-wide change which can make the system unusable so if you + are unsure then use one of the other methods described above. +

        • Use the ldd utility on the linked executable to show which libstdc++.so diff --git a/libstdc++-v3/doc/html/manual/using_exceptions.html b/libstdc++-v3/doc/html/manual/using_exceptions.html index 39fc1e05cfd..dc8c4daec8b 100644 --- a/libstdc++-v3/doc/html/manual/using_exceptions.html +++ b/libstdc++-v3/doc/html/manual/using_exceptions.html @@ -8,12 +8,12 @@ the throw keyword. These are very powerful constructs, and require some thought when applied to the standard library in order to yield components that work efficiently while cleaning up resources when unexpectedly killed via -exceptional circumstances. +exceptional circumstances.

        Two general topics of discussion follow: exception neutrality and exception safety. -

        Exception Safety

        - What is exception-safe code? +

        Exception Safety

        + What is exception-safe code?

        Will define this as reasonable and well-defined behavior by classes and functions from the standard library when used by user-defined @@ -124,7 +124,7 @@ exception neutrality and exception safety. use -fno-exceptions. If you have some code that uses try or catch, you shouldn't use -fno-exceptions. -

        +

        And what it to be gained, tinkering in the back alleys with a language like this? Exception handling overhead can be measured in the size of the executable binary, and varies with the @@ -194,7 +194,7 @@ exception neutrality and exception safety. library has been transformed, user code may need modification. User code that attempts or expects to do error checking on standard library components compiled with exception handling disabled should - be evaluated and potentially made conditional. + be evaluated and potentially made conditional.

        Some issues remain with this approach (see bugzilla entry 25191). Code paths are not equivalent, in @@ -220,7 +220,7 @@ exception neutrality and exception safety. substitution of the C language keyword const with the uglified doppelganger __const. -

        Compatibility

        With C

        +

        Compatibility

        With C

        C language code that is expecting to interoperate with C++ should be compiled with -fexceptions. This will make debugging a C language function called as part of C++-induced stack @@ -235,7 +235,7 @@ is called. getting these details right. For GNU systems, all appropriate parts of the GNU C library are already compiled with -fexceptions. -

        With POSIX thread cancellation

        +

        With POSIX thread cancellation

        GNU systems re-use some of the exception handling mechanisms to track control flow for POSIX thread cancellation.

        @@ -266,54 +266,63 @@ is called. } catch(...) { this->_M_setstate(ios_base::badbit); } -

        Bibliography

        - System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) - . +

        Bibliography

        + + + System Interface Definitions, Issue 7 (IEEE Std. 1003.1-2008) + + + . 2.9.5 Thread Cancellation . Copyright © 2008 - The Open Group/The Institute of Electrical and Electronics Engineers, Inc.. - - - .

        - Error and Exception Handling - . David Abrahams . - Boost - . + The Open Group/The Institute of Electrical and Electronics + Engineers, Inc. + .

        + + Error and Exception Handling + - .

        - Exception-Safety in Generic Components - . David Abrahams. + . David Abrahams . Boost - . + .

        + + Exception-Safety in Generic Components + - .

        - Standard Library Exception Policy - . Matt Austern. - WG21 N1077 - . + . David Abrahams. + Boost + .

        + + Standard Library Exception Policy + - .

        - ia64 c++ abi exception handling - . Richard Henderson. - GNU - . + . Matt Austern. + WG21 N1077 + .

        + + ia64 c++ abi exception handling + - .

        - Appendix E: Standard-Library Exception Safety - . Bjarne Stroustrup. + . Richard Henderson. + GNU + .

        + + Appendix E: Standard-Library Exception Safety + - .

        + . Bjarne Stroustrup.

        Exceptional C++ . Exception-Safety Issues and Techniques - . Herb Sutter.

        - exception_defines.h #defines try/catch - . - GCC Bug 25191 - . + . Herb Sutter.

        + + + GCC Bug 25191: exception_defines.h #defines try/catch + + .

        Prev Up Next
        Concurrency Home Debugging Support
        diff --git a/libstdc++-v3/doc/html/manual/using_headers.html b/libstdc++-v3/doc/html/manual/using_headers.html index 5ce54466d6f..155d82874bc 100644 --- a/libstdc++-v3/doc/html/manual/using_headers.html +++ b/libstdc++-v3/doc/html/manual/using_headers.html @@ -20,19 +20,19 @@ upcoming 200x standard.

        C++98/03 include files. These are available in the default compilation mode, i.e. -std=c++98 or -std=gnu++98. -

        Table 3.2. C++ 1998 Library Headers

        algorithmbitsetcomplexdequeexception
        fstreamfunctionaliomanipiosiosfwd
        iostreamistreamiteratorlimitslist
        localemapmemorynewnumeric
        ostreamqueuesetsstreamstack
        stdexceptstreambufstringutilitytypeinfo
        valarrayvector   

        Table 3.3. C++ 1998 Library Headers for C Library Facilities

        cassertcerrnocctypecfloatciso646
        climitsclocalecmathcsetjmpcsignal
        cstdargcstddefcstdiocstdlibcstring
        ctimecwcharcwctype  

        +

        Table 3.2. C++ 1998 Library Headers

        algorithmbitsetcomplexdequeexception
        fstreamfunctionaliomanipiosiosfwd
        iostreamistreamiteratorlimitslist
        localemapmemorynewnumeric
        ostreamqueuesetsstreamstack
        stdexceptstreambufstringutilitytypeinfo
        valarrayvector   

        Table 3.3. C++ 1998 Library Headers for C Library Facilities

        cassertcerrnocctypecfloatciso646
        climitsclocalecmathcsetjmpcsignal
        cstdargcstddefcstdiocstdlibcstring
        ctimecwcharcwctype  

        C++0x include files. These are only available in C++0x compilation mode, i.e. -std=c++0x or -std=gnu++0x. -

        Table 3.4. C++ 200x Library Headers

        algorithmarraybitsetchronocomplex
        condition_variabledequeexceptionforward_listfstream
        functionalfutureinitalizer_listiomanipios
        iosfwdiostreamistreamiteratorlimits
        listlocalemapmemorymutex
        newnumericostreamqueuerandom
        ratioregexsetsstreamstack
        stdexceptstreambufstringsystem_errorthread
        tupletype_traitstypeinfounordered_mapunordered_set
        utilityvalarrayvector  

        Table 3.5. C++ 200x Library Headers for C Library Facilities

        cassertccomplexcctypecerrnocfenv
        cfloatcinttypesciso646climitsclocale
        cmathcsetjmpcsignalcstdargcstdbool
        cstddefcstdintcstdlibcstdiocstring
        ctgmathctimecucharcwcharcwctype
        stdatomic.h    

        +

        Table 3.4. C++ 200x Library Headers

        algorithmarraybitsetchronocomplex
        condition_variabledequeexceptionforward_listfstream
        functionalfutureinitalizer_listiomanipios
        iosfwdiostreamistreamiteratorlimits
        listlocalemapmemorymutex
        newnumericostreamqueuerandom
        ratioregexsetsstreamstack
        stdexceptstreambufstringsystem_errorthread
        tupletype_traitstypeinfounordered_mapunordered_set
        utilityvalarrayvector  

        Table 3.5. C++ 200x Library Headers for C Library Facilities

        cassertccomplexcctypecerrnocfenv
        cfloatcinttypesciso646climitsclocale
        cmathcsetjmpcsignalcstdargcstdbool
        cstddefcstdintcstdlibcstdiocstring
        ctgmathctimecucharcwcharcwctype
        stdatomic.h    

        In addition, TR1 includes as: -

        Table 3.6. C++ TR 1 Library Headers

        tr1/arraytr1/complextr1/memorytr1/functionaltr1/random
        tr1/regextr1/tupletr1/type_traitstr1/unordered_maptr1/unordered_set
        tr1/utility    

        Table 3.7. C++ TR 1 Library Headers for C Library Facilities

        tr1/ccomplextr1/cfenvtr1/cfloattr1/cmathtr1/cinttypes
        tr1/climitstr1/cstdargtr1/cstdbooltr1/cstdinttr1/cstdio
        tr1/cstdlibtr1/ctgmathtr1/ctimetr1/cwchartr1/cwctype

        Decimal floating-point arithmetic is available if the C++ +

        Table 3.6. C++ TR 1 Library Headers

        tr1/arraytr1/complextr1/memorytr1/functionaltr1/random
        tr1/regextr1/tupletr1/type_traitstr1/unordered_maptr1/unordered_set
        tr1/utility    

        Table 3.7. C++ TR 1 Library Headers for C Library Facilities

        tr1/ccomplextr1/cfenvtr1/cfloattr1/cmathtr1/cinttypes
        tr1/climitstr1/cstdargtr1/cstdbooltr1/cstdinttr1/cstdio
        tr1/cstdlibtr1/ctgmathtr1/ctimetr1/cwchartr1/cwctype

        Decimal floating-point arithmetic is available if the C++ compiler supports scalar decimal floating-point types defined via __attribute__((mode(SD|DD|LD))). -

        Table 3.8. C++ TR 24733 Decimal Floating-Point Header

        decimal/decimal

        +

        Table 3.8. C++ TR 24733 Decimal Floating-Point Header

        decimal/decimal

        Also included are files for the C++ ABI interface: -

        Table 3.9. C++ ABI Headers

        cxxabi.hcxxabi_forced.h

        +

        Table 3.9. C++ ABI Headers

        cxxabi.hcxxabi_forced.h

        And a large variety of extensions. -

        Table 3.10. Extension Headers

        ext/algorithmext/atomicity.hext/array_allocator.hext/bitmap_allocator.hext/cast.h
        ext/codecvt_specializations.hext/concurrence.hext/debug_allocator.hext/enc_filebuf.hext/extptr_allocator.h
        ext/functionalext/iteratorext/malloc_allocator.hext/memoryext/mt_allocator.h
        ext/new_allocator.hext/numericext/numeric_traits.hext/pb_ds/assoc_container.hext/pb_ds/priority_queue.h
        ext/pod_char_traits.hext/pool_allocator.hext/rb_treeext/ropeext/slist
        ext/stdio_filebuf.hext/stdio_sync_filebuf.hext/throw_allocator.hext/typelist.hext/type_traits.h
        ext/vstring.h    

        Table 3.11. Extension Debug Headers

        debug/bitsetdebug/dequedebug/listdebug/mapdebug/set
        debug/stringdebug/unordered_mapdebug/unordered_setdebug/vector 

        Table 3.12. Extension Profile Headers

        profile/bitsetprofile/dequeprofile/listprofile/map
        profile/setprofile/unordered_mapprofile/unordered_setprofile/vector

        Table 3.13. Extension Parallel Headers

        parallel/algorithmparallel/numeric

        Mixing Headers

        A few simple rules. +

        Table 3.10. Extension Headers

        ext/algorithmext/atomicity.hext/array_allocator.hext/bitmap_allocator.hext/cast.h
        ext/codecvt_specializations.hext/concurrence.hext/debug_allocator.hext/enc_filebuf.hext/extptr_allocator.h
        ext/functionalext/iteratorext/malloc_allocator.hext/memoryext/mt_allocator.h
        ext/new_allocator.hext/numericext/numeric_traits.hext/pb_ds/assoc_container.hext/pb_ds/priority_queue.h
        ext/pod_char_traits.hext/pool_allocator.hext/rb_treeext/ropeext/slist
        ext/stdio_filebuf.hext/stdio_sync_filebuf.hext/throw_allocator.hext/typelist.hext/type_traits.h
        ext/vstring.h    

        Table 3.11. Extension Debug Headers

        debug/bitsetdebug/dequedebug/listdebug/mapdebug/set
        debug/stringdebug/unordered_mapdebug/unordered_setdebug/vector 

        Table 3.12. Extension Profile Headers

        profile/bitsetprofile/dequeprofile/listprofile/map
        profile/setprofile/unordered_mapprofile/unordered_setprofile/vector

        Table 3.13. Extension Parallel Headers

        parallel/algorithmparallel/numeric

        Mixing Headers

        A few simple rules.

        First, mixing different dialects of the standard headers is not possible. It's an all-or-nothing affair. Thus, code like 

        diff --git a/libstdc++-v3/doc/html/manual/using_macros.html b/libstdc++-v3/doc/html/manual/using_macros.html
index 9daf4d3405c..ded3c5a4c35 100644
--- a/libstdc++-v3/doc/html/manual/using_macros.html
+++ b/libstdc++-v3/doc/html/manual/using_macros.html
@@ -59,19 +59,19 @@
 	--enable-concept-checks.  When defined, performs
 	compile-time checking on certain template instantiations to
 	detect violations of the requirements of the standard.  This
-	is described in more detail here.
+	is described in more detail here.
       
        _GLIBCXX_DEBUG
        
 	Undefined by default. When defined, compiles user code using
-    the debug mode.
+    the debug mode.
       
        _GLIBCXX_DEBUG_PEDANTIC
        
 	Undefined by default. When defined while compiling with
-    the debug mode, makes
+    the debug mode, makes
     the debug mode extremely picky by making the use of libstdc++
     extensions and libstdc++-specific behavior into errors.
       
        _GLIBCXX_PARALLEL
        Undefined by default. When defined, compiles user code
-    using the parallel
+    using the parallel
     mode.
       
        _GLIBCXX_PROFILE
        Undefined by default. When defined, compiles user code
-    using the profile
+    using the profile
     mode.
        Prev Up Next
        Headers Home Namespaces
        diff --git a/libstdc++-v3/doc/html/manual/utilities.html b/libstdc++-v3/doc/html/manual/utilities.html dissimilarity index 91% index 643a52964a9..9a801d7a6b3 100644 --- a/libstdc++-v3/doc/html/manual/utilities.html +++ b/libstdc++-v3/doc/html/manual/utilities.html @@ -1,9 +1,17 @@ - - -Part IV.  Utilities
        Part IV.  - Utilities - -
        Prev The GNU C++ Library Next

        Part IV.  - Utilities - -

        Table of Contents

        9. Functors
        10. Pairs
        11. Memory
        Allocators
        Requirements
        Design Issues
        Implementation
        Using a Specific Allocator
        Custom Allocators
        Extension Allocators
        auto_ptr
        Limitations
        Use in Containers
        shared_ptr
        Requirements
        Design Issues
        Implementation
        Use
        Acknowledgments
        12. Traits
        Prev Up Next
        Adding Data to Exceptions Home Chapter 9. Functors
        + + +Chapter 6.  Utilities
        Chapter 6.  + Utilities + +
        Prev Part II.  + Standard Contents + Next

        Chapter 6.  + Utilities + +

        Table of Contents

        Functors
        Pairs
        Memory
        Allocators
        auto_ptr
        shared_ptr
        Traits

        Functors

        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 chapter of their STL, in + their + http://www.sgi.com/tech/stl/functors.html. +

        Prev Up Next
        Concept Checking Home Pairs
        diff --git a/libstdc++-v3/doc/html/manual/vector.html b/libstdc++-v3/doc/html/manual/vector.html deleted file mode 100644 index 8f554385943..00000000000 --- a/libstdc++-v3/doc/html/manual/vector.html +++ /dev/null @@ -1,13 +0,0 @@ - - -vector
        vector
        Prev Chapter 16. Sequences Next

        vector

        -

        Space Overhead Management

        - In this - message to the list, Daniel Kostecky announced work on an - alternate form of std::vector that would support - hints on the number of elements to be over-allocated. The design - was also described, along with possible implementation choices. -

        - The first two alpha releases were announced here - and here. -

        Prev Up Next
        Chapter 16. Sequences Home Chapter 17. Associative
        diff --git a/libstdc++-v3/doc/html/manual/verbose_termination.html b/libstdc++-v3/doc/html/manual/verbose_termination.html deleted file mode 100644 index 540e5a77577..00000000000 --- a/libstdc++-v3/doc/html/manual/verbose_termination.html +++ /dev/null @@ -1,79 +0,0 @@ - - -Verbose Terminate Handler
        Verbose Terminate Handler
        Prev Chapter 6. Termination Next

        Verbose Terminate Handler

        - If you are having difficulty with uncaught exceptions and want a - little bit of help debugging the causes of the core dumps, you can - make use of a GNU extension, the verbose terminate handler. - 

        -#include <exception>
-  
-int main()
-{
-  std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
-  ...
-
-  throw anything;
-}
-

        - The __verbose_terminate_handler function - obtains the name of the current exception, attempts to demangle - it, and prints it to stderr. If the exception is derived from - exception then the output from - what() will be included. -

        - Any replacement termination function is required to kill the - program without returning; this one calls abort. -

        - For example: - 

        -#include <exception>
-#include <stdexcept>
-
-struct argument_error : public std::runtime_error
-{  
-  argument_error(const std::string& s): std::runtime_error(s) { }
-};
-
-int main(int argc)
-{
-  std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
-  if (argc > 5)
-    throw argument_error(“argc is greater than 5!”);
-  else
-    throw argc;
-}
-

        - With the verbose terminate handler active, this gives: - 

        -   
-   % ./a.out
-   terminate called after throwing a `int'
-   Aborted
-   % ./a.out f f f f f f f f f f f
-   terminate called after throwing an instance of `argument_error'
-   what(): argc is greater than 5!
-   Aborted
-   
-

        - The 'Aborted' line comes from the call to - abort(), of course. -

        - This is the default termination handler; nothing need be done to - use it. To go back to the previous “silent death” - method, simply include exception and - cstdlib, and call - 

        -     std::set_terminate(std::abort);
-

        - After this, all calls to terminate will use - abort as the terminate handler. -

        - Note: the verbose terminate handler will attempt to write to - stderr. If your application closes stderr or redirects it to an - inappropriate location, - __verbose_terminate_handler will behave in - an unspecified manner. -

        Prev Up Next
        Chapter 6. Termination Home Part III.  - Diagnostics - -
        diff --git a/libstdc++-v3/doc/html/spine.html b/libstdc++-v3/doc/html/spine.html index edcf88aae34..585f7cdf1ea 100644 --- a/libstdc++-v3/doc/html/spine.html +++ b/libstdc++-v3/doc/html/spine.html @@ -5,43 +5,53 @@

        Table of Contents

        The GNU C++ Library
        I. Introduction -
        1. Status
        Implementation Status
        C++ 1998/2003
        C++ 200x
        C++ TR1
        C++ TR 24733
        License
        The Code: GPL
        The Documentation: GPL, FDL
        Bugs
        Implementation Bugs
        Standard Bugs
        2. Setup
        Prerequisites
        Configure
        Make
        3. Using
        Command Options
        Headers
        Header Files
        Mixing Headers
        The C Headers and namespace std
        Precompiled Headers
        Macros
        Namespaces
        Available Namespaces
        namespace std
        Using Namespace Composition
        Linking
        Almost Nothing
        Finding Dynamic or Shared Libraries
        Concurrency
        Prerequisites
        Thread Safety
        Atomics
        IO
        Containers
        Exceptions
        Exception Safety
        Exception Neutrality
        Doing without
        Compatibility
        Debugging Support
        Using g++
        Debug Versions of Library Binary Files
        Memory Leak Hunting
        Using gdb
        Tracking uncaught exceptions
        Debug Mode
        Compile Time Checking
        Profile-based Performance Analysis
        II. +
        1. Status
        Implementation Status
        C++ 1998/2003
        C++ 200x
        C++ TR1
        C++ TR 24733
        License
        The Code: GPL
        The Documentation: GPL, FDL
        Bugs
        Implementation Bugs
        Standard Bugs
        2. Setup
        Prerequisites
        Configure
        Make
        3. Using
        Command Options
        Headers
        Header Files
        Mixing Headers
        The C Headers and namespace std
        Precompiled Headers
        Macros
        Namespaces
        Available Namespaces
        namespace std
        Using Namespace Composition
        Linking
        Almost Nothing
        Finding Dynamic or Shared Libraries
        Concurrency
        Prerequisites
        Thread Safety
        Atomics
        IO
        Containers
        Exceptions
        Exception Safety
        Exception Neutrality
        Doing without
        Compatibility
        Debugging Support
        Using g++
        Debug Versions of Library Binary Files
        Memory Leak Hunting
        Using gdb
        Tracking uncaught exceptions
        Debug Mode
        Compile Time Checking
        Profile-based Performance Analysis
        II. + Standard Contents +
        4. Support -
        4. Types
        Fundamental Types
        Numeric Properties
        NULL
        5. Dynamic Memory
        6. Termination
        Termination Handlers
        Verbose Terminate Handler
        III. +
        Types
        Fundamental Types
        Numeric Properties
        NULL
        Dynamic Memory
        Termination
        Termination Handlers
        Verbose Terminate Handler
        5. Diagnostics -
        7. Exceptions
        Exception Classes
        Adding Data to Exceptions
        8. Concept Checking
        IV. +
        Exceptions
        API Reference
        Adding Data to exception
        Concept Checking
        6. Utilities -
        9. Functors
        10. Pairs
        11. Memory
        Allocators
        Requirements
        Design Issues
        Implementation
        Using a Specific Allocator
        Custom Allocators
        Extension Allocators
        auto_ptr
        Limitations
        Use in Containers
        shared_ptr
        Requirements
        Design Issues
        Implementation
        Use
        Acknowledgments
        12. Traits
        V. +
        Functors
        Pairs
        Memory
        Allocators
        auto_ptr
        shared_ptr
        Traits
        7. Strings -
        13. String Classes
        Simple Transformations
        Case Sensitivity
        Arbitrary Character Types
        Tokenizing
        Shrink to Fit
        CString (MFC)
        VI. +
        String Classes
        Simple Transformations
        Case Sensitivity
        Arbitrary Character Types
        Tokenizing
        Shrink to Fit
        CString (MFC)
        8. Localization -
        14. Locales
        locale
        Requirements
        Design
        Implementation
        Future
        15. Facets aka Categories
        ctype
        Implementation
        Future
        codecvt
        Requirements
        Design
        Implementation
        Use
        Future
        messages
        Requirements
        Design
        Implementation
        Use
        Future
        VII. +
        Locales
        locale
        Facets
        ctype
        codecvt
        messages
        9. Containers -
        16. Sequences
        list
        list::size() is O(n)
        vector
        Space Overhead Management
        17. Associative
        Insertion Hints
        bitset
        Size Variable
        Type String
        18. Interacting with C
        Containers vs. Arrays
        VIII. +
        Sequences
        list
        vector
        Associative
        Insertion Hints
        bitset
        Interacting with C
        Containers vs. Arrays
        10. Iterators -
        19. Predefined
        Iterators vs. Pointers
        One Past the End
        IX. +
        Predefined
        Iterators vs. Pointers
        One Past the End
        11. Algorithms -
        20. Mutating
        swap
        Specializations
        X. +
        Mutating
        swap
        12. Numerics -
        21. Complex
        complex Processing
        22. Generalized Operations
        23. Interacting with C
        Numerics vs. Arrays
        C99
        XI. +
        Complex
        complex Processing
        Generalized Operations
        Interacting with C
        Numerics vs. Arrays
        C99
        13. Input and Output -
        24. Iostream Objects
        25. Stream Buffers
        Derived streambuf Classes
        Buffering
        26. Memory Based Streams
        Compatibility With strstream
        27. File Based Streams
        Copying a File
        Binary Input and Output
        28. Interacting with C
        Using FILE* and file descriptors
        Performance
        XII. +
        Iostream Objects
        Stream Buffers
        Derived streambuf Classes
        Buffering
        Memory Based Streams
        Compatibility With strstream
        File Based Streams
        Copying a File
        Binary Input and Output
        Interacting with C
        Using FILE* and file descriptors
        Performance
        14. + Atomics + +
        API Reference
        15. + Concurrency + +
        API Reference
        III. Extensions -
        29. Compile Time Checks
        30. Debug Mode
        Intro
        Semantics
        Using
        Using the Debug Mode
        Using a Specific Debug Container
        Design
        Goals
        Methods
        Other Implementations
        31. Parallel Mode
        Intro
        Semantics
        Using
        Prerequisite Compiler Flags
        Using Parallel Mode
        Using Specific Parallel Components
        Design
        Interface Basics
        Configuration and Tuning
        Implementation Namespaces
        Testing
        Bibliography
        32. Profile Mode
        Intro
        Using the Profile Mode
        Tuning the Profile Mode
        Design
        Wrapper Model
        Instrumentation
        Run Time Behavior
        Analysis and Diagnostics
        Cost Model
        Reports
        Testing
        Extensions for Custom Containers
        Empirical Cost Model
        Implementation Issues
        Stack Traces
        Symbolization of Instruction Addresses
        Concurrency
        Using the Standard Library in the Instrumentation Implementation
        Malloc Hooks
        Construction and Destruction of Global Objects
        Developer Information
        Big Picture
        How To Add A Diagnostic
        Diagnostics
        Diagnostic Template
        Containers
        Algorithms
        Data Locality
        Multithreaded Data Access
        Statistics
        Bibliography
        33. Allocators
        mt_allocator
        Intro
        Design Issues
        Implementation
        Single Thread Example
        Multiple Thread Example
        bitmap_allocator
        Design
        Implementation
        34. Containers
        Policy Based Data Structures
        HP/SGI
        Deprecated HP/SGI
        35. Utilities
        36. Algorithms
        37. Numerics
        38. Iterators
        39. Input and Output
        Derived filebufs
        40. Demangling
        41. Concurrency
        Design
        Interface to Locks and Mutexes
        Interface to Atomic Functions
        Implementation
        Using Builtin Atomic Functions
        Thread Abstraction
        Use
        A. +
        16. Compile Time Checks
        17. Debug Mode
        Intro
        Semantics
        Using
        Using the Debug Mode
        Using a Specific Debug Container
        Design
        Goals
        Methods
        Other Implementations
        18. Parallel Mode
        Intro
        Semantics
        Using
        Prerequisite Compiler Flags
        Using Parallel Mode
        Using Specific Parallel Components
        Design
        Interface Basics
        Configuration and Tuning
        Implementation Namespaces
        Testing
        Bibliography
        19. Profile Mode
        Intro
        Using the Profile Mode
        Tuning the Profile Mode
        Design
        Wrapper Model
        Instrumentation
        Run Time Behavior
        Analysis and Diagnostics
        Cost Model
        Reports
        Testing
        Extensions for Custom Containers
        Empirical Cost Model
        Implementation Issues
        Stack Traces
        Symbolization of Instruction Addresses
        Concurrency
        Using the Standard Library in the Instrumentation Implementation
        Malloc Hooks
        Construction and Destruction of Global Objects
        Developer Information
        Big Picture
        How To Add A Diagnostic
        Diagnostics
        Diagnostic Template
        Containers
        Algorithms
        Data Locality
        Multithreaded Data Access
        Statistics
        Bibliography
        20. Allocators
        mt_allocator
        Intro
        Design Issues
        Implementation
        Single Thread Example
        Multiple Thread Example
        bitmap_allocator
        Design
        Implementation
        21. Containers
        Policy Based Data Structures
        HP/SGI
        Deprecated HP/SGI
        22. Utilities
        23. Algorithms
        24. Numerics
        25. Iterators
        26. Input and Output
        Derived filebufs
        27. Demangling
        28. Concurrency
        Design
        Interface to Locks and Mutexes
        Interface to Atomic Functions
        Implementation
        Using Builtin Atomic Functions
        Thread Abstraction
        Use
        IV. + Appendices +
        A. Contributing -
        Contributor Checklist
        Reading
        Assignment
        Getting Sources
        Submitting Patches
        Directory Layout and Source Conventions
        Coding Style
        Bad Identifiers
        By Example
        Documentation Style
        Doxygen
        Docbook
        Design Notes
        B. +
        Contributor Checklist
        Reading
        Assignment
        Getting Sources
        Submitting Patches
        Directory Layout and Source Conventions
        Coding Style
        Bad Identifiers
        By Example
        Documentation Style
        Doxygen
        Docbook
        Combines
        Design Notes
        B. Porting and Maintenance
        Configure and Build Hacking
        Prerequisites
        Overview: What Comes from Where
        Storing Information in non-AC files (like configure.host)
        Coding and Commenting Conventions
        The acinclude.m4 layout
        GLIBCXX_ENABLE, the --enable maker
        Porting to New Hardware or Operating Systems
        Operating System
        CPU
        Character Types
        Thread Safety
        Numeric Limits
        Libtool
        Test
        Organization
        Running the Testsuite
        Writing a new test case
        Test Harness and Utilities
        Special Topics
        ABI Policy and Guidelines
        The C++ Interface
        Versioning
        Allowed Changes
        Prohibited Changes
        Implementation
        Testing
        Outstanding Issues
        API Evolution and Deprecation History
        3.0
        3.1
        3.2
        3.3
        3.4
        4.0
        4.1
        4.2
        4.3
        4.4
        4.5
        Backwards Compatibility
        First
        Second
        Third
        C. @@ -49,4 +59,4 @@
        D. GNU General Public License version 3 -
        E. GNU Free Documentation License
        Index
        API and Source Level Documentation
        Frequently Asked Questions
           Next
           The GNU C++ Library
        +
        E. GNU Free Documentation License
        API Documentation
        Frequently Asked Questions
           Next
           The GNU C++ Library
        diff --git a/libstdc++-v3/doc/xml/faq.xml b/libstdc++-v3/doc/xml/faq.xml index 7a0953ccbe0..22d2e629010 100644 --- a/libstdc++-v3/doc/xml/faq.xml +++ b/libstdc++-v3/doc/xml/faq.xml @@ -387,6 +387,11 @@ linker has different names on different platforms but the man page is usually called something such as ld.so/rtld/dld.so. + + Using LD_LIBRARY_PATH is not always the best solution, Finding Dynamic or Shared + Libraries in the manual gives some alternatives. + @@ -895,8 +900,9 @@ More information, including how to optionally enable/disable the - checks, is available - here. + checks, is available in the + Diagnostics. + chapter of the manual. diff --git a/libstdc++-v3/doc/xml/manual/appendix_contributing.xml b/libstdc++-v3/doc/xml/manual/appendix_contributing.xml index 279e7038a9b..393b7f509c3 100644 --- a/libstdc++-v3/doc/xml/manual/appendix_contributing.xml +++ b/libstdc++-v3/doc/xml/manual/appendix_contributing.xml @@ -920,7 +920,7 @@ indicate a place that may require attention for multi-thread safety. Prerequisites - Prerequisite tools are Bash 2.x, + Prerequisite tools are Bash 2.0 or later, Doxygen, and the GNU coreutils. (GNU versions of find, xargs, and possibly diff --git a/libstdc++-v3/doc/xml/manual/prerequisites.xml b/libstdc++-v3/doc/xml/manual/prerequisites.xml index cdfe6ccccb1..d7a162c056a 100644 --- a/libstdc++-v3/doc/xml/manual/prerequisites.xml +++ b/libstdc++-v3/doc/xml/manual/prerequisites.xml @@ -41,6 +41,12 @@ + To generate the API documentation from the sources you will need + Doxygen, see Documentation + Style in the appendix for full details. + + + Finally, a few system-specific requirements: diff --git a/libstdc++-v3/doc/xml/manual/strings.xml b/libstdc++-v3/doc/xml/manual/strings.xml index 412484e8ef2..8eb9b49a1be 100644 --- a/libstdc++-v3/doc/xml/manual/strings.xml +++ b/libstdc++-v3/doc/xml/manual/strings.xml @@ -366,6 +366,10 @@ stringtok(Container &container, string const &in, entry) but the regular copy constructor cannot be used because libstdc++'s string is Copy-On-Write. + In C++0x mode you can call + s.shrink_to_fit() to achieve the same effect as + s.reserve(s.size()). + diff --git a/libstdc++-v3/doc/xml/manual/using.xml b/libstdc++-v3/doc/xml/manual/using.xml index e4863c2e4dc..bb6077c4e19 100644 --- a/libstdc++-v3/doc/xml/manual/using.xml +++ b/libstdc++-v3/doc/xml/manual/using.xml @@ -1176,22 +1176,42 @@ A quick read of the relevant part of the GCC - GNU ld (default on Linux):-Wl,--rpath,destdir/lib + GNU ld (default on Linux): + -Wl,-rpath,destdir/lib - IRIX ld: - -Wl,-rpath,destdir/lib + IRIX ld: + -Wl,-rpath,destdir/lib - Solaris ld:-Wl,-Rdestdir/lib + Solaris ld: + -Wl,-Rdestdir/lib + + + Some linkers allow you to specify the path to the library by + setting LD_RUN_PATH in your environment + when linking. + + + + + On some platforms the system administrator can configure the + dynamic linker to always look for libraries in + destdir/lib, for example + by using the ldconfig utility on Linux + or the crle utility on Solaris. This is a + system-wide change which can make the system unusable so if you + are unsure then use one of the other methods described above. + + Use the ldd utility on the linked executable diff --git a/libstdc++-v3/include/parallel/partition.h b/libstdc++-v3/include/parallel/partition.h index 6a9c4aceaa6..0d5a139968c 100644 --- a/libstdc++-v3/include/parallel/partition.h +++ b/libstdc++-v3/include/parallel/partition.h @@ -66,27 +66,26 @@ namespace __gnu_parallel const _Settings& __s = _Settings::get(); - // Shared. - _GLIBCXX_VOLATILE _DifferenceType __left = 0, __right = __n - 1; - _GLIBCXX_VOLATILE _DifferenceType __leftover_left, __leftover_right; - _GLIBCXX_VOLATILE _DifferenceType __leftnew, __rightnew; + // shared + _GLIBCXX_VOLATILE _DifferenceType __left = 0, __right = __n - 1, + __dist = __n, + __leftover_left, __leftover_right, + __leftnew, __rightnew; - bool* __reserved_left = NULL, * __reserved_right = NULL; + // just 0 or 1, but int to allow atomic operations + int* __reserved_left = NULL, * __reserved_right = NULL; _DifferenceType __chunk_size = __s.partition_chunk_size; - omp_lock_t __result_lock; - omp_init_lock(&__result_lock); - //at least two chunks per thread - if (__right - __left + 1 >= 2 * __num_threads * __chunk_size) + if (__dist >= 2 * __num_threads * __chunk_size) # pragma omp parallel num_threads(__num_threads) { # pragma omp single { __num_threads = omp_get_num_threads(); - __reserved_left = new bool[__num_threads]; - __reserved_right = new bool[__num_threads]; + __reserved_left = new int[__num_threads]; + __reserved_right = new int[__num_threads]; if (__s.partition_chunk_share > 0.0) __chunk_size = std::max<_DifferenceType> @@ -96,17 +95,16 @@ namespace __gnu_parallel __chunk_size = __s.partition_chunk_size; } - while (__right - __left + 1 >= 2 * __num_threads * __chunk_size) + while (__dist >= 2 * __num_threads * __chunk_size) { # pragma omp single { - _DifferenceType __num_chunks = ((__right - __left + 1) - / __chunk_size); + _DifferenceType __num_chunks = __dist / __chunk_size; for (_ThreadIndex __r = 0; __r < __num_threads; ++__r) { - __reserved_left[__r] = false; - __reserved_right[__r] = false; + __reserved_left [__r] = 0; // false + __reserved_right[__r] = 0; // false } __leftover_left = 0; __leftover_right = 0; @@ -115,11 +113,13 @@ namespace __gnu_parallel // Private. _DifferenceType __thread_left, __thread_left_border, __thread_right, __thread_right_border; - __thread_left = __left + 1; + __thread_left = __left + 1; // Just to satisfy the condition below. __thread_left_border = __thread_left - 1; + __thread_right = __n - 1; + // Just to satisfy the condition below. __thread_right_border = __thread_right + 1; bool __iam_finished = false; @@ -127,35 +127,42 @@ namespace __gnu_parallel { if (__thread_left > __thread_left_border) { - omp_set_lock(&__result_lock); - if (__left + (__chunk_size - 1) > __right) - __iam_finished = true; - else - { - __thread_left = __left; - __thread_left_border = __left + (__chunk_size - 1); - __left += __chunk_size; - } - omp_unset_lock(&__result_lock); + _DifferenceType __former_dist = + __fetch_and_add(&__dist, -__chunk_size); + if (__former_dist < __chunk_size) + { + __fetch_and_add(&__dist, __chunk_size); + __iam_finished = true; + break; + } + else + { + __thread_left = + __fetch_and_add(&__left, __chunk_size); + __thread_left_border = + __thread_left + (__chunk_size - 1); + } } if (__thread_right < __thread_right_border) { - omp_set_lock(&__result_lock); - if (__left > __right - (__chunk_size - 1)) - __iam_finished = true; - else - { - __thread_right = __right; - __thread_right_border = __right - (__chunk_size - 1); - __right -= __chunk_size; - } - omp_unset_lock(&__result_lock); + _DifferenceType __former_dist = + __fetch_and_add(&__dist, -__chunk_size); + if (__former_dist < __chunk_size) + { + __fetch_and_add(&__dist, __chunk_size); + __iam_finished = true; + break; + } + else + { + __thread_right = + __fetch_and_add(&__right, -__chunk_size); + __thread_right_border = + __thread_right - (__chunk_size - 1); + } } - if (__iam_finished) - break; - // Swap as usual. while (__thread_left < __thread_right) { @@ -188,13 +195,11 @@ namespace __gnu_parallel # pragma omp barrier -# pragma omp single - { - __leftnew = __left - __leftover_left * __chunk_size; - __rightnew = __right + __leftover_right * __chunk_size; - } - -# pragma omp barrier + _DifferenceType + __leftold = __left, + __leftnew = __left - __leftover_left * __chunk_size, + __rightold = __right, + __rightnew = __right + __leftover_right * __chunk_size; // <=> __thread_left_border + (__chunk_size - 1) >= __leftnew if (__thread_left <= __thread_left_border @@ -202,7 +207,7 @@ namespace __gnu_parallel { // Chunk already in place, reserve spot. __reserved_left[(__left - (__thread_left_border + 1)) - / __chunk_size] = true; + / __chunk_size] = 1; } // <=> __thread_right_border - (__chunk_size - 1) <= __rightnew @@ -211,7 +216,7 @@ namespace __gnu_parallel { // Chunk already in place, reserve spot. __reserved_right[((__thread_right_border - 1) - __right) - / __chunk_size] = true; + / __chunk_size] = 1; } # pragma omp barrier @@ -221,15 +226,13 @@ namespace __gnu_parallel { // Find spot and swap. _DifferenceType __swapstart = -1; - omp_set_lock(&__result_lock); - for (_DifferenceType __r = 0; __r < __leftover_left; ++__r) - if (!__reserved_left[__r]) - { - __reserved_left[__r] = true; - __swapstart = __left - (__r + 1) * __chunk_size; - break; - } - omp_unset_lock(&__result_lock); + for (int __r = 0; __r < __leftover_left; ++__r) + if (__reserved_left[__r] == 0 + && __compare_and_swap(&(__reserved_left[__r]), 0, 1)) + { + __swapstart = __leftold - (__r + 1) * __chunk_size; + break; + } #if _GLIBCXX_ASSERTIONS _GLIBCXX_PARALLEL_ASSERT(__swapstart != -1); @@ -246,15 +249,13 @@ namespace __gnu_parallel { // Find spot and swap _DifferenceType __swapstart = -1; - omp_set_lock(&__result_lock); - for (_DifferenceType __r = 0; __r < __leftover_right; ++__r) - if (!__reserved_right[__r]) - { - __reserved_right[__r] = true; - __swapstart = __right + __r * __chunk_size + 1; - break; - } - omp_unset_lock(&__result_lock); + for (int __r = 0; __r < __leftover_right; ++__r) + if (__reserved_right[__r] == 0 + && __compare_and_swap(&(__reserved_right[__r]), 0, 1)) + { + __swapstart = __rightold + __r * __chunk_size + 1; + break; + } #if _GLIBCXX_ASSERTIONS _GLIBCXX_PARALLEL_ASSERT(__swapstart != -1); @@ -270,18 +271,15 @@ namespace __gnu_parallel # pragma omp single { for (_DifferenceType __r = 0; __r < __leftover_left; ++__r) - _GLIBCXX_PARALLEL_ASSERT(__reserved_left[__r]); + _GLIBCXX_PARALLEL_ASSERT(__reserved_left[__r] == 1); for (_DifferenceType __r = 0; __r < __leftover_right; ++__r) - _GLIBCXX_PARALLEL_ASSERT(__reserved_right[__r]); + _GLIBCXX_PARALLEL_ASSERT(__reserved_right[__r] == 1); } - -# pragma omp barrier #endif -# pragma omp barrier - __left = __leftnew; __right = __rightnew; + __dist = __right - __left + 1; } # pragma omp flush(__left, __right) @@ -313,8 +311,6 @@ namespace __gnu_parallel delete[] __reserved_left; delete[] __reserved_right; - omp_destroy_lock(&__result_lock); - // Element "between" __final_left and __final_right might not have // been regarded yet if (__final_left < __n && !__pred(__begin[__final_left])) -- 2.11.4.GIT