- Update GCC to version 3.4.3.
authorJoerg Sonnenberger <joerg@dragonflybsd.org>
Mon, 20 Dec 2004 19:23:26 +0000 (19:23 +0000)
committerJoerg Sonnenberger <joerg@dragonflybsd.org>
Mon, 20 Dec 2004 19:23:26 +0000 (19:23 +0000)
- Remove some unused files from the repository.
- Change default debug format back to DWARF-2, since gdb 6 works better with
  it.
- Compile libobjc dynamically too, it helps e.g. GnuStep.
- Install MMX/SSE/... support headers under /usr/libdata/gcc34.

148 files changed:
contrib/gcc-3.4/BUGS
contrib/gcc-3.4/FAQ
contrib/gcc-3.4/LAST_UPDATED
contrib/gcc-3.4/MAINTAINERS
contrib/gcc-3.4/README.DELETED
contrib/gcc-3.4/README.DRAGONFLY
contrib/gcc-3.4/README.SCO
contrib/gcc-3.4/gcc/alias.c
contrib/gcc-3.4/gcc/basic-block.h
contrib/gcc-3.4/gcc/bb-reorder.c
contrib/gcc-3.4/gcc/c-common.c
contrib/gcc-3.4/gcc/c-decl.c
contrib/gcc-3.4/gcc/c-opts.c
contrib/gcc-3.4/gcc/c-parse.in
contrib/gcc-3.4/gcc/c-ppoutput.c
contrib/gcc-3.4/gcc/c-semantics.c
contrib/gcc-3.4/gcc/c-typeck.c
contrib/gcc-3.4/gcc/calls.c
contrib/gcc-3.4/gcc/cfglayout.c
contrib/gcc-3.4/gcc/cfglayout.h
contrib/gcc-3.4/gcc/cfgrtl.c
contrib/gcc-3.4/gcc/combine.c
contrib/gcc-3.4/gcc/common.opt
contrib/gcc-3.4/gcc/config/i386/emmintrin.h
contrib/gcc-3.4/gcc/config/i386/i386.c
contrib/gcc-3.4/gcc/config/i386/i386.md
contrib/gcc-3.4/gcc/config/i386/xmmintrin.h
contrib/gcc-3.4/gcc/cp/call.c
contrib/gcc-3.4/gcc/cp/class.c
contrib/gcc-3.4/gcc/cp/cp-tree.h
contrib/gcc-3.4/gcc/cp/cxx-pretty-print.c
contrib/gcc-3.4/gcc/cp/decl.c
contrib/gcc-3.4/gcc/cp/decl2.c
contrib/gcc-3.4/gcc/cp/error.c
contrib/gcc-3.4/gcc/cp/except.c
contrib/gcc-3.4/gcc/cp/g++spec.c
contrib/gcc-3.4/gcc/cp/init.c
contrib/gcc-3.4/gcc/cp/mangle.c
contrib/gcc-3.4/gcc/cp/name-lookup.c
contrib/gcc-3.4/gcc/cp/parser.c
contrib/gcc-3.4/gcc/cp/pt.c
contrib/gcc-3.4/gcc/cp/search.c
contrib/gcc-3.4/gcc/cp/semantics.c
contrib/gcc-3.4/gcc/cp/tree.c
contrib/gcc-3.4/gcc/cp/typeck.c
contrib/gcc-3.4/gcc/cp/typeck2.c
contrib/gcc-3.4/gcc/cppexp.c
contrib/gcc-3.4/gcc/cppfiles.c
contrib/gcc-3.4/gcc/cpphash.h
contrib/gcc-3.4/gcc/cppinit.c
contrib/gcc-3.4/gcc/crtstuff.c
contrib/gcc-3.4/gcc/cse.c
contrib/gcc-3.4/gcc/cselib.c
contrib/gcc-3.4/gcc/cselib.h
contrib/gcc-3.4/gcc/dbxout.c
contrib/gcc-3.4/gcc/doc/bugreport.texi
contrib/gcc-3.4/gcc/doc/configterms.texi
contrib/gcc-3.4/gcc/doc/contrib.texi
contrib/gcc-3.4/gcc/doc/contribute.texi
contrib/gcc-3.4/gcc/doc/cpp.texi
contrib/gcc-3.4/gcc/doc/cppinternals.texi
contrib/gcc-3.4/gcc/doc/cppopts.texi
contrib/gcc-3.4/gcc/doc/extend.texi
contrib/gcc-3.4/gcc/doc/include/gcc-common.texi
contrib/gcc-3.4/gcc/doc/install.texi
contrib/gcc-3.4/gcc/doc/invoke.texi
contrib/gcc-3.4/gcc/doc/md.texi
contrib/gcc-3.4/gcc/doc/portability.texi
contrib/gcc-3.4/gcc/doc/sourcebuild.texi
contrib/gcc-3.4/gcc/doc/tm.texi
contrib/gcc-3.4/gcc/doc/trouble.texi
contrib/gcc-3.4/gcc/dwarf2out.c
contrib/gcc-3.4/gcc/expmed.c
contrib/gcc-3.4/gcc/f/bld.c
contrib/gcc-3.4/gcc/f/bld.h
contrib/gcc-3.4/gcc/f/malloc.c
contrib/gcc-3.4/gcc/flow.c
contrib/gcc-3.4/gcc/fold-const.c
contrib/gcc-3.4/gcc/function.c
contrib/gcc-3.4/gcc/gcc.c
contrib/gcc-3.4/gcc/gcse.c
contrib/gcc-3.4/gcc/gthr-win32.h
contrib/gcc-3.4/gcc/hooks.c
contrib/gcc-3.4/gcc/hooks.h
contrib/gcc-3.4/gcc/ifcvt.c
contrib/gcc-3.4/gcc/jump.c
contrib/gcc-3.4/gcc/libgcc2.c
contrib/gcc-3.4/gcc/loop-init.c
contrib/gcc-3.4/gcc/loop.c
contrib/gcc-3.4/gcc/postreload.c
contrib/gcc-3.4/gcc/regclass.c
contrib/gcc-3.4/gcc/regs.h
contrib/gcc-3.4/gcc/reload.c
contrib/gcc-3.4/gcc/rtl.h
contrib/gcc-3.4/gcc/sibcall.c
contrib/gcc-3.4/gcc/simplify-rtx.c
contrib/gcc-3.4/gcc/target-def.h
contrib/gcc-3.4/gcc/target.h
contrib/gcc-3.4/gcc/toplev.c
contrib/gcc-3.4/gcc/tracer.c
contrib/gcc-3.4/gcc/tree-inline.c
contrib/gcc-3.4/gcc/tree-optimize.c
contrib/gcc-3.4/gcc/tree.c
contrib/gcc-3.4/gcc/tree.h
contrib/gcc-3.4/gcc/unwind-dw2-fde-glibc.c
contrib/gcc-3.4/gcc/unwind-dw2.c
contrib/gcc-3.4/gcc/varasm.c
contrib/gcc-3.4/gcc/version.c
contrib/gcc-3.4/libiberty/ChangeLog
contrib/gcc-3.4/libobjc/ChangeLog
contrib/gcc-3.4/libstdc++-v3/ChangeLog
contrib/gcc-3.4/libstdc++-v3/README
contrib/gcc-3.4/libstdc++-v3/config/linker-map.gnu
contrib/gcc-3.4/libstdc++-v3/config/locale/generic/c_locale.cc
contrib/gcc-3.4/libstdc++-v3/config/locale/generic/c_locale.h
contrib/gcc-3.4/libstdc++-v3/config/locale/generic/time_members.cc
contrib/gcc-3.4/libstdc++-v3/config/os/bsd/netbsd/ctype_base.h [deleted file]
contrib/gcc-3.4/libstdc++-v3/config/os/bsd/netbsd/ctype_inline.h [deleted file]
contrib/gcc-3.4/libstdc++-v3/config/os/bsd/netbsd/ctype_noninline.h [deleted file]
contrib/gcc-3.4/libstdc++-v3/config/os/bsd/netbsd/os_defines.h [deleted file]
contrib/gcc-3.4/libstdc++-v3/include/bits/basic_string.h
contrib/gcc-3.4/libstdc++-v3/include/bits/basic_string.tcc
contrib/gcc-3.4/libstdc++-v3/include/bits/boost_concept_check.h
contrib/gcc-3.4/libstdc++-v3/include/bits/c++config
contrib/gcc-3.4/libstdc++-v3/include/bits/concurrence.h
contrib/gcc-3.4/libstdc++-v3/include/bits/cpp_type_traits.h
contrib/gcc-3.4/libstdc++-v3/include/bits/fstream.tcc
contrib/gcc-3.4/libstdc++-v3/include/bits/istream.tcc
contrib/gcc-3.4/libstdc++-v3/include/bits/locale_facets.tcc
contrib/gcc-3.4/libstdc++-v3/include/bits/sstream.tcc
contrib/gcc-3.4/libstdc++-v3/include/bits/stl_algo.h
contrib/gcc-3.4/libstdc++-v3/include/c_std/std_cwchar.h
contrib/gcc-3.4/libstdc++-v3/include/debug/formatter.h
contrib/gcc-3.4/libstdc++-v3/include/debug/map.h
contrib/gcc-3.4/libstdc++-v3/include/debug/safe_base.h
contrib/gcc-3.4/libstdc++-v3/include/ext/mt_allocator.h
contrib/gcc-3.4/libstdc++-v3/include/ext/pool_allocator.h
contrib/gcc-3.4/libstdc++-v3/include/ext/ropeimpl.h
contrib/gcc-3.4/libstdc++-v3/include/std/std_fstream.h
contrib/gcc-3.4/libstdc++-v3/include/std/std_memory.h
contrib/gcc-3.4/libstdc++-v3/include/std/std_sstream.h
contrib/gcc-3.4/libstdc++-v3/libsupc++/tinfo.cc
contrib/gcc-3.4/libstdc++-v3/src/allocator-inst.cc
contrib/gcc-3.4/libstdc++-v3/src/allocator.cc
contrib/gcc-3.4/libstdc++-v3/src/debug.cc
contrib/gcc-3.4/libstdc++-v3/src/ios_init.cc
contrib/gcc-3.4/libstdc++-v3/src/locale_init.cc
contrib/gcc-3.4/libstdc++-v3/src/localename.cc

index 05d7210..e4de179 100644 (file)
@@ -318,7 +318,7 @@ B b((0,A()),A(1));
 
 return A();
 
-          This  problem  occured  in  a  number  of  variants;  in  throw
+          This  problem  occurred  in  a  number  of  variants;  in throw
           statements,   people   also   frequently   put  the  object  in
           parentheses.
      _________________________________________________________________
@@ -376,6 +376,36 @@ int main()
 
 C
 
+   Increment/decrement operator (++/--) not working as expected - a
+          [32]problem with many variations.
+          The following expressions have unpredictable results:
+
+x[i]=++i
+foo(i,++i)
+i*(++i)                 /* special case with foo=="operator*" */
+std::cout << i << ++i   /* foo(foo(std::cout,i),++i)          */
+
+          since  the i without increment can be evaluated before or after
+          ++i.
+
+          The  C  and C++ standards have the notion of "sequence points".
+          Everything  that happens between two sequence points happens in
+          an  unspecified order, but it has to happen after the first and
+          before  the second sequence point. The end of a statement and a
+          function   call  are  examples  for  sequence  points,  whereas
+          assignments and the comma between function arguments are not.
+
+          Modifying a value twice between two sequence points as shown in
+          the following examples is even worse:
+
+i=++i
+foo(++i,++i)
+(++i)*(++i)               /* special case with foo=="operator*" */
+std::cout << ++i << ++i   /* foo(foo(std::cout,++i),++i)        */
+
+          This  leads  to  undefined  behavior  (i.e. the compiler can do
+          anything).
+
    Casting does not work as expected when optimization is turned on.
           This  is  often  caused by a violation of aliasing rules, which
           are  part of the ISO C standard. These rules say that a program
@@ -452,7 +482,7 @@ int main()
           Now the result will always be "2222 2222".
 
           For  some  more insight into the subject, please have a look at
-          [32]this article.
+          [33]this article.
 
    Cannot use preprocessor directive in macro arguments.
           Let  me  guess...  you  used an older version of GCC to compile
@@ -527,7 +557,7 @@ FILE *yyin = stdin;
 
           There  is  a  common  misconception that the GCC developers are
           responsible  for  GNU  libc.  These  are  in  fact two entirely
-          separate  projects; please check the [33]GNU libc web pages for
+          separate  projects; please check the [34]GNU libc web pages for
           details.
      _________________________________________________________________
 
@@ -643,7 +673,7 @@ void bar(void)
    you might want to recompile all libraries to be safe. It should not be
    necessary to recompile if you have changed to a bug-fix release of the
    same  version  of  the compiler; bug-fix releases are careful to avoid
-   ABI changes. See also the [34]compatibility section of the GCC manual.
+   ABI changes. See also the [35]compatibility section of the GCC manual.
 
    Remark:  A  major  release  is  designated by a change to the first or
    second  component  of  the  two- or three-part version number. A minor
@@ -656,11 +686,11 @@ void bar(void)
     Standard conformance
 
    With  each  release,  we try to make G++ conform closer to the ISO C++
-   standard  (available  at  [35]http://www.ncits.org/cplusplus.htm).  We
+   standard  (available  at  [36]http://www.ncits.org/cplusplus.htm).  We
    have  also  implemented  some  of  the core and library defect reports
    (available at
-   [36]http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html     &
-   [37]http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html
+   [37]http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html     &
+   [38]http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html
    respectively).
 
    Non-conforming  legacy code that worked with older versions of GCC may
@@ -765,7 +795,7 @@ template <typename T> struct B : A<T>
 };
 
    In  addition  to  the  problems  listed  above,  the manual contains a
-   section on [38]Common Misunderstandings with GNU C++.
+   section on [39]Common Misunderstandings with GNU C++.
 
 References
 
@@ -800,10 +830,11 @@ References
   29. http://gcc.gnu.org/onlinedocs/g77/Trouble.html
   30. http://gcc.gnu.org/PR323
   31. http://www.validlab.com/goldberg/paper.ps
-  32. http://mail-index.NetBSD.org/tech-kern/2003/08/11/0001.html
-  33. http://www.gnu.org/software/libc/
-  34. http://gcc.gnu.org/onlinedocs/gcc/Compatibility.html
-  35. http://www.ncits.org/cplusplus.htm
-  36. http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html
-  37. http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html
-  38. http://gcc.gnu.org/onlinedocs/gcc/C---Misunderstandings.html
+  32. http://gcc.gnu.org/PR11751
+  33. http://mail-index.NetBSD.org/tech-kern/2003/08/11/0001.html
+  34. http://www.gnu.org/software/libc/
+  35. http://gcc.gnu.org/onlinedocs/gcc/Compatibility.html
+  36. http://www.ncits.org/cplusplus.htm
+  37. http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html
+  38. http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html
+  39. http://gcc.gnu.org/onlinedocs/gcc/C---Misunderstandings.html
index 571b83e..a131156 100644 (file)
@@ -415,7 +415,7 @@ dynamic_cast, throw, typeid don't work with shared libraries
    The new C++ ABI in the GCC 3.0 series uses address comparisons, rather
    than string compares, to determine type equality. This leads to better
    performance.  Like  other objects that have to be present in the final
-   executable,  these  std::typeinfo_t  objects have what is called vague
+   executable,  these  std::type_info  objects  have what is called vague
    linkage  because  they  are  not  tightly  bound to any one particular
    translation  unit  (object file). The compiler has to emit them in any
    translation  unit  that  requires their presence, and then rely on the
@@ -426,7 +426,7 @@ dynamic_cast, throw, typeid don't work with shared libraries
    a  shared  library  are resolved against objects in the executable and
    other shared libraries.
      * For  a  program  which  is  linked  against  a  shared library, no
-       additional precautions need taking.
+       additional precautions are needed.
      * You  cannot  create a shared library with the "-Bsymbolic" option,
        as that prevents the resolution described above.
      * If  you  use dlopen to explicitly load code from a shared library,
@@ -455,7 +455,7 @@ dynamic_cast, throw, typeid don't work with shared libraries
 
    For more details about the way that GCC implements these and other C++
    features,   please   read   the   [40]ABI   specification.   Note  the
-   std::typeinfo_t  objects which must be resolved all begin with "_ZTS".
+   std::type_info  objects  which must be resolved all begin with "_ZTS".
    Refer   to  ld's  documentation  for  a  description  of  the  "-E"  &
    "-Bsymbolic" flags.
      _________________________________________________________________
index 51be09d..e25a3dc 100644 (file)
@@ -1 +1 @@
-Obtained from CVS: -rgcc-ss-3_4-20040618 
+Obtained from CVS: -rgcc_3_4_3_release 
index b7ded19..71d343e 100644 (file)
@@ -282,7 +282,7 @@ John Wehle                                  john@feith.com
 Florian Weimer                                 fw@deneb.enyo.de
 Mark Wielaard                                  mark@gcc.gnu.org
 Carlo Wood                                     carlo@alinoe.com
-Josef Zlomek                                   zlomekj@suse.cz
+Josef Zlomek                                   josef.zlomek@email.cz
 
 Bug database only accounts
 
index 337af5c..2a12119 100644 (file)
@@ -43,6 +43,7 @@
 ./gcc/README-fixinc
 ./gcc/README.Portability
 ./gcc/aclocal.m4
+./gcc/c-config-lang.in
 ./gcc/config.build
 ./gcc/config.gcc
 ./gcc/config.host
 ./gcc/cp/Make-lang.in
 ./gcc/cp/NEWS
 ./gcc/cp/config-lang.in
+./gcc/cppucnid.pl
+./gcc/cppucnid.tab
+./gcc/cstamp-h.in
+./gcc/doc/install.texi2html
 ./gcc/f/ChangeLog
 ./gcc/f/ChangeLog.0
 ./gcc/f/Make-lang.in
 ./gcc/fixinc
 ./gcc/fixproto
 ./gcc/gccbug.in
+./gcc/gdbinit.in
 ./gcc/ginclude
 ./gcc/libgcc-darwin.ver
 ./gcc/libgcc-std.ver
 ./libstdc++-v3/config/cpu/sparc
 ./libstdc++-v3/config/locale/gnu
 ./libstdc++-v3/config/os/aix
+./libstdc++-v3/config/os/bsd/netbsd
 ./libstdc++-v3/config/os/djgpp
 ./libstdc++-v3/config/os/gnu-linux
 ./libstdc++-v3/config/os/hpux
index 34564a4..2dce450 100644 (file)
@@ -1,8 +1,8 @@
 
-                       GCC-3.4-20040126 AS USED BY DRAGONFLY
+                       GCC-3.4.3 AS USED BY DRAGONFLY
 
     This directory contains a selected set of files from the gnu 
-    gcc-3.4-20040618 distribution.  The entire distribution is 188MB but
+    gcc-3.4.3 distribution.  The entire distribution is 188MB but
     we really only need around 31MB of it.  No files have been moved
     or modified from their extracted position.
 
     on the distribution.  The only additional files added to this directory
     are README.DRAGONFLY and README.DELETED. 
 
-       MD5 (gcc-3.4-20040618.tar.bz2) = 6eb0e85c225250cc40b75496419d4250
+       MD5 (gcc-3.4.3.tar.bz2) = e744b30c834360fccac41eb7269a3011
 
     UPGRADE PROCDURE:
 
-       * download a new gcc-3.4.X dist greater then 3.4-20040618
-         (the release after this snapshot would be gcc-3.4.1).
+       * download a new gcc-3.4.X dist greater then 3.4.3.
 
        * extract the archive into this directory, overlaying the
          existing files.
index f86b82b..6b28fe3 100644 (file)
@@ -1,27 +1,10 @@
-As all users of GCC will know, SCO has recently made claims concerning
-alleged copyright infringement by recent versions of the operating
-system kernel called Linux.  SCO has made irresponsible public
-statements about this supposed copyright infringement without
-releasing any evidence of the infringement, and has demanded that
-users of Linux, the kernel most often used with the GNU system, pay
-for a license.  This license is incompatible with the GPL, and in the
-opinion of the Free Software Foundation such a demand unquestionably
-violates the GNU General Public License under which the kernel is
-distributed.
+The GCC team has been urged to drop support for SCO Unix from GCC, as
+a protest against SCO's irresponsible aggression against free software
+and GNU/Linux.  We have decided to take no action at this time, as we
+no longer believe that SCO is a serious threat.
+
+For more on the FSF's position regarding SCO's attacks on free
+software, please read:
+
+  http://www.gnu.org/philosophy/sco/sco.html
 
-We have been urged to drop support for SCO Unix from this release of
-GCC, as a protest against this irresponsible aggression against free
-software and GNU/Linux.  However, the direct effect of this action
-would fall on users of GCC rather than on SCO.  For the moment, we
-have decided not to take that action.  The Free Software Foundation's
-overriding goal is to protect the freedom of the free software
-community, including developers and users, but we also want to serve
-users.  Protecting the community from an attack sometimes requires
-steps that will inconvenience some in the community.  Such a step is
-not yet necessary, in our view, but we cannot indefinitely continue to
-ignore the aggression against our community taken by a party that has
-long profited from the commercial distribution of our programs.  We
-urge users of SCO Unix to make clear to SCO their disapproval of the
-company's aggression against the free software community.  We will
-have a further announcement concerning continuing support of SCO Unix
-by GCC before our next release.
index dab10ac..5cce5e4 100644 (file)
@@ -500,6 +500,8 @@ get_alias_set (tree t)
              /* If we haven't computed the actual alias set, do it now.  */
              if (DECL_POINTER_ALIAS_SET (decl) == -2)
                {
+                 tree pointed_to_type = TREE_TYPE (TREE_TYPE (decl));
+
                  /* No two restricted pointers can point at the same thing.
                     However, a restricted pointer can point at the same thing
                     as an unrestricted pointer, if that unrestricted pointer
@@ -508,11 +510,22 @@ get_alias_set (tree t)
                     alias set for the type pointed to by the type of the
                     decl.  */
                  HOST_WIDE_INT pointed_to_alias_set
-                   = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
+                   = get_alias_set (pointed_to_type);
 
                  if (pointed_to_alias_set == 0)
                    /* It's not legal to make a subset of alias set zero.  */
                    DECL_POINTER_ALIAS_SET (decl) = 0;
+                 else if (AGGREGATE_TYPE_P (pointed_to_type))
+                   /* For an aggregate, we must treat the restricted
+                      pointer the same as an ordinary pointer.  If we
+                      were to make the type pointed to by the
+                      restricted pointer a subset of the pointed-to
+                      type, then we would believe that other subsets
+                      of the pointed-to type (such as fields of that
+                      type) do not conflict with the type pointed to
+                      by the restricted pointer.   */
+                   DECL_POINTER_ALIAS_SET (decl)
+                     = pointed_to_alias_set;
                  else
                    {
                      DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
index 10cc635..5c6dd5c 100644 (file)
@@ -606,7 +606,7 @@ extern bool inside_basic_block_p (rtx);
 extern bool control_flow_insn_p (rtx);
 
 /* In bb-reorder.c */
-extern void reorder_basic_blocks (void);
+extern void reorder_basic_blocks (unsigned int);
 
 /* In dominance.c */
 
index fc50b64..a8b3280 100644 (file)
@@ -1063,10 +1063,11 @@ get_uncond_jump_length (void)
   return length;
 }
 
-/* Reorder basic blocks.  The main entry point to this file.  */
+/* Reorder basic blocks.  The main entry point to this file.  FLAGS is
+   the set of flags to pass to cfg_layout_initialize().  */
 
 void
-reorder_basic_blocks (void)
+reorder_basic_blocks (unsigned int flags)
 {
   int n_traces;
   int i;
@@ -1080,7 +1081,7 @@ reorder_basic_blocks (void)
 
   timevar_push (TV_REORDER_BLOCKS);
 
-  cfg_layout_initialize ();
+  cfg_layout_initialize (flags);
 
   set_edge_can_fallthru_flag ();
   mark_dfs_back_edges ();
index c5f4dad..ff78e41 100644 (file)
@@ -767,7 +767,6 @@ static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
                                                 bool *);
-static tree vector_size_helper (tree, tree);
 
 static void check_function_nonnull (tree, tree);
 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
@@ -4643,7 +4642,10 @@ handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
       else
        for (j = 0; j < NUM_MACHINE_MODES; j++)
          if (!strcmp (p, GET_MODE_NAME (j)))
-           mode = (enum machine_mode) j;
+           {
+             mode = (enum machine_mode) j;
+             break;
+           }
 
       if (mode == VOIDmode)
        error ("unknown machine mode `%s'", p);
@@ -4676,8 +4678,17 @@ handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
                                                        mode);
              *node = ptr_type;
            }
+         else if (VECTOR_MODE_P (mode)
+                  ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
+                  : TREE_CODE (type) != TREE_CODE (typefm))
+                  
+           {
+             error ("mode `%s' applied to inappropriate type", p);
+             return NULL_TREE;
+           }
          else
-         *node = typefm;
+           *node = typefm;
+
          /* No need to layout the type here.  The caller should do this.  */
        }
     }
@@ -5246,57 +5257,11 @@ handle_vector_size_attribute (tree *node, tree name, tree args,
     }
 
   /* Build back pointers if needed.  */
-  *node = vector_size_helper (*node, new_type);
+  *node = reconstruct_complex_type (*node, new_type);
 
   return NULL_TREE;
 }
 
-/* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
-   better way.
-
-   If we requested a pointer to a vector, build up the pointers that
-   we stripped off while looking for the inner type.  Similarly for
-   return values from functions.
-
-   The argument "type" is the top of the chain, and "bottom" is the
-   new type which we will point to.  */
-
-static tree
-vector_size_helper (tree type, tree bottom)
-{
-  tree inner, outer;
-
-  if (POINTER_TYPE_P (type))
-    {
-      inner = vector_size_helper (TREE_TYPE (type), bottom);
-      outer = build_pointer_type (inner);
-    }
-  else if (TREE_CODE (type) == ARRAY_TYPE)
-    {
-      inner = vector_size_helper (TREE_TYPE (type), bottom);
-      outer = build_array_type (inner, TYPE_DOMAIN (type));
-    }
-  else if (TREE_CODE (type) == FUNCTION_TYPE)
-    {
-      inner = vector_size_helper (TREE_TYPE (type), bottom);
-      outer = build_function_type (inner, TYPE_ARG_TYPES (type));
-    }
-  else if (TREE_CODE (type) == METHOD_TYPE)
-    {
-      inner = vector_size_helper (TREE_TYPE (type), bottom);
-      outer = build_method_type_directly (TYPE_METHOD_BASETYPE (type),
-                                         inner, 
-                                         TYPE_ARG_TYPES (type));
-    }
-  else
-    return bottom;
-
-  TREE_READONLY (outer) = TREE_READONLY (type);
-  TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
-
-  return outer;
-}
-
 /* Handle the "nonnull" attribute.  */
 static tree
 handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
index 7e3f245..88e097b 100644 (file)
@@ -1253,6 +1253,11 @@ diagnose_mismatched_decls (tree newdecl, tree olddecl,
         definition.  */
       && !(TREE_CODE (newdecl) == FUNCTION_DECL
           && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
+      /* Don't warn about redundant redeclarations of builtins. */
+      && !(TREE_CODE (newdecl) == FUNCTION_DECL
+          && !DECL_BUILT_IN (newdecl)
+          && DECL_BUILT_IN (olddecl)
+          && C_DECL_INVISIBLE (olddecl))
       /* Don't warn about an extern followed by a definition.  */
       && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
       /* Don't warn about forward parameter decls.  */
@@ -3978,7 +3983,17 @@ grokdeclarator (tree declarator, tree declspecs,
        }
       else if (TREE_CODE (declarator) == CALL_EXPR)
        {
+         /* Say it's a definition only for the declarator closest to
+            the identifier, apart possibly from some attributes.  */
+         bool really_funcdef = false;
          tree arg_types;
+         if (funcdef_flag)
+           {
+             tree t = TREE_OPERAND (declarator, 0);
+             while (TREE_CODE (t) == TREE_LIST)
+               t = TREE_VALUE (t);
+             really_funcdef = (TREE_CODE (t) == IDENTIFIER_NODE);
+           }
 
          /* Declaring a function type.
             Make sure we have a valid type for the function to return.  */
@@ -4004,11 +4019,7 @@ grokdeclarator (tree declarator, tree declspecs,
             inner layer of declarator.  */
 
          arg_types = grokparms (TREE_OPERAND (declarator, 1),
-                                funcdef_flag
-                                /* Say it's a definition
-                                   only for the CALL_EXPR
-                                   closest to the identifier.  */
-                                && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
+                                really_funcdef);
          /* Type qualifiers before the return type of the function
             qualify the return type, not the function type.  */
          if (type_quals)
index 93637a2..5a351d9 100644 (file)
@@ -186,10 +186,10 @@ defer_opt (enum opt_code code, const char *arg)
 
 /* Common initialization before parsing options.  */
 unsigned int
-c_common_init_options (unsigned int argc, const char **argv ATTRIBUTE_UNUSED)
+c_common_init_options (unsigned int argc, const char **argv)
 {
   static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
-  unsigned int result;
+  unsigned int i, result;
 
   /* This is conditionalized only because that is the way the front
      ends used to do it.  Maybe this should be unconditional?  */
@@ -222,17 +222,25 @@ c_common_init_options (unsigned int argc, const char **argv ATTRIBUTE_UNUSED)
 
   result = lang_flags[c_language];
 
-  /* If potentially preprocessing Fortran we have to accept its front
-     end options since the driver passes most of them through.  */
-#ifdef CL_F77
-  if (c_language == clk_c && argc > 2
-      && !strcmp (argv[2], "-traditional-cpp" ))
+  if (c_language == clk_c)
     {
-      permit_fortran_options = true;
-      result |= CL_F77;
-    }
+      for (i = 1; i < argc; i++)
+       {
+         /* If preprocessing assembly language, accept any of the C-family
+            front end options since the driver may pass them through.  */
+         if (! strcmp (argv[i], "-lang-asm"))
+           result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
+#ifdef CL_F77
+         /* If potentially preprocessing Fortran we have to accept its
+            front end options since the driver may them through.  */
+         else if (! strcmp (argv[i], "-traditional-cpp"))
+           {
+             permit_fortran_options = true;
+             result |= CL_F77;
+           }
 #endif
-
+       }
+    }
   return result;
 }
 
index f035266..66d27ac 100644 (file)
@@ -2149,7 +2149,7 @@ compstmt_contents_nonempty:
 
 compstmt_primary_start:
        '(' '{'
-               { if (current_function_decl == 0)
+               { if (last_tree == NULL)
                    {
                      error ("braced-group within expression allowed only inside a function");
                      YYERROR;
index e97c9bc..5588da3 100644 (file)
@@ -292,7 +292,7 @@ cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED, fileline line,
          const cpp_string *str)
 {
   maybe_print_line (print.map, line);
-  fprintf (print.outf, "#ident \"%s\"\n", str->text);
+  fprintf (print.outf, "#ident %s\n", str->text);
   print.line++;
 }
 
index 38c4021..080f0c6 100644 (file)
@@ -969,7 +969,9 @@ expand_unreachable_if_stmt (tree t)
 /* Expand an unreachable statement list.  This function skips all
    statements preceding the first potentially reachable label and
    then returns the label (or, in same cases, the statement after
-   one containing the label).  */
+   one containing the label).  This function returns NULL_TREE if
+   the end of the given statement list is unreachable, and a
+   non-NULL value, possibly error_mark_node, otherwise.  */
 static tree
 expand_unreachable_stmt (tree t, int warn)
 {
@@ -1019,7 +1021,7 @@ expand_unreachable_stmt (tree t, int warn)
 
        case IF_STMT:
          if (expand_unreachable_if_stmt (t))
-           return TREE_CHAIN (t);
+           return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node;
          break;
 
        case WHILE_STMT:
@@ -1027,7 +1029,7 @@ expand_unreachable_stmt (tree t, int warn)
             no need to rotate the loop, instead the WHILE_STMT can be
             expanded like a DO_STMT.  */
          genrtl_do_stmt_1 (WHILE_COND (t), WHILE_BODY (t));
-         return TREE_CHAIN (t);
+         return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node;
 
        case COMPOUND_STMT:
          {
@@ -1036,7 +1038,7 @@ expand_unreachable_stmt (tree t, int warn)
            if (n != NULL_TREE)
              {
                expand_stmt (n);
-               return TREE_CHAIN (t);
+               return TREE_CHAIN (t) ? TREE_CHAIN (t) : error_mark_node;
              }
            warn = false;
            break;
index c8d71e1..dd06fda 100644 (file)
@@ -1320,26 +1320,6 @@ build_component_ref (tree datum, tree component)
   tree field = NULL;
   tree ref;
 
-  /* If DATUM is a COMPOUND_EXPR, move our reference inside it.
-     If pedantic ensure that the arguments are not lvalues; otherwise,
-     if the component is an array, it would wrongly decay to a pointer in
-     C89 mode.
-     We cannot do this with a COND_EXPR, because in a conditional expression
-     the default promotions are applied to both sides, and this would yield
-     the wrong type of the result; for example, if the components have
-     type "char".  */
-  switch (TREE_CODE (datum))
-    {
-    case COMPOUND_EXPR:
-      {
-       tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
-       return build (COMPOUND_EXPR, TREE_TYPE (value),
-                     TREE_OPERAND (datum, 0), pedantic_non_lvalue (value));
-      }
-    default:
-      break;
-    }
-
   /* See if there is a field or component with name COMPONENT.  */
 
   if (code == RECORD_TYPE || code == UNION_TYPE)
index 7562809..5dc96c6 100644 (file)
@@ -2405,6 +2405,26 @@ expand_call (tree exp, rtx target, int ignore)
     num_actuals++;
 
   /* Compute number of named args.
+     First, do a raw count of the args for INIT_CUMULATIVE_ARGS.  */
+
+  if (type_arg_types != 0)
+    n_named_args
+      = (list_length (type_arg_types)
+        /* Count the struct value address, if it is passed as a parm.  */
+        + structure_value_addr_parm);
+  else
+    /* If we know nothing, treat all args as named.  */
+    n_named_args = num_actuals;
+
+  /* Start updating where the next arg would go.
+
+     On some machines (such as the PA) indirect calls have a different
+     calling convention than normal calls.  The fourth argument in
+     INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
+     or not.  */
+  INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, fndecl, n_named_args);
+
+  /* Now possibly adjust the number of named args.
      Normally, don't include the last named arg if anonymous args follow.
      We do include the last named arg if
      targetm.calls.strict_argument_naming() returns nonzero.
@@ -2422,27 +2442,17 @@ expand_call (tree exp, rtx target, int ignore)
      we do not have any reliable way to pass unnamed args in
      registers, so we must force them into memory.  */
 
-  if ((targetm.calls.strict_argument_naming (&args_so_far)
-       || ! targetm.calls.pretend_outgoing_varargs_named (&args_so_far))
-      && type_arg_types != 0)
-    n_named_args
-      = (list_length (type_arg_types)
-        /* Don't include the last named arg.  */
-        - (targetm.calls.strict_argument_naming (&args_so_far) ? 0 : 1)
-        /* Count the struct value address, if it is passed as a parm.  */
-        + structure_value_addr_parm);
+  if (type_arg_types != 0
+      && targetm.calls.strict_argument_naming (&args_so_far))
+    ;
+  else if (type_arg_types != 0
+          && ! targetm.calls.pretend_outgoing_varargs_named (&args_so_far))
+    /* Don't include the last named arg.  */
+    --n_named_args;
   else
-    /* If we know nothing, treat all args as named.  */
+    /* Treat all args as named.  */
     n_named_args = num_actuals;
 
-  /* Start updating where the next arg would go.
-
-     On some machines (such as the PA) indirect calls have a different
-     calling convention than normal calls.  The last argument in
-     INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
-     or not.  */
-  INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, fndecl, n_named_args);
-
   /* Make a vector to hold all the information about each arg.  */
   args = alloca (num_actuals * sizeof (struct arg_data));
   memset (args, 0, num_actuals * sizeof (struct arg_data));
index 15ec054..fa1b82c 100644 (file)
@@ -865,6 +865,18 @@ fixup_fallthru_exit_predecessor (void)
     {
       basic_block c = ENTRY_BLOCK_PTR->next_bb;
 
+      /* If the very first block is the one with the fall-through exit
+        edge, we have to split that block.  */
+      if (c == bb)
+       {
+         bb = split_block (bb, NULL)->dest;
+         cfg_layout_initialize_rbi (bb);
+         bb->rbi->next = c->rbi->next;
+         c->rbi->next = bb;
+         bb->rbi->footer = c->rbi->footer;
+         c->rbi->footer = NULL;
+       }
+
       while (c->rbi->next != bb)
        c = c->rbi->next;
 
@@ -1118,10 +1130,14 @@ cfg_layout_initialize_rbi (basic_block bb)
 }
 \f
 /* Main entry point to this module - initialize the datastructures for
-   CFG layout changes.  It keeps LOOPS up-to-date if not null.  */
+   CFG layout changes.  It keeps LOOPS up-to-date if not null.
+
+   FLAGS is a set of additional flags to pass to cleanup_cfg().  It should
+   include CLEANUP_UPDATE_LIFE if liveness information must be kept up
+   to date.  */
 
 void
-cfg_layout_initialize (void)
+cfg_layout_initialize (unsigned int flags)
 {
   basic_block bb;
 
@@ -1137,7 +1153,7 @@ cfg_layout_initialize (void)
 
   record_effective_endpoints ();
 
-  cleanup_cfg (CLEANUP_CFGLAYOUT);
+  cleanup_cfg (CLEANUP_CFGLAYOUT | flags);
 }
 
 /* Splits superblocks.  */
index ca79e26..c0b250e 100644 (file)
@@ -35,7 +35,7 @@ typedef struct reorder_block_def
 
 extern rtx cfg_layout_function_footer;
 
-extern void cfg_layout_initialize (void);
+extern void cfg_layout_initialize (unsigned int);
 extern void cfg_layout_finalize (void);
 extern bool cfg_layout_can_duplicate_bb_p (basic_block);
 extern basic_block cfg_layout_duplicate_bb (basic_block, edge);
index bad9e77..42899f4 100644 (file)
@@ -483,9 +483,21 @@ rtl_split_block (basic_block bb, void *insnp)
   edge e;
   rtx insn = insnp;
 
-  /* There is no point splitting the block after its end.  */
-  if (BB_END (bb) == insn)
-    return 0;
+  if (!insn)
+    {
+      insn = first_insn_after_basic_block_note (bb);
+
+      if (insn)
+       insn = PREV_INSN (insn);
+      else
+       insn = get_last_insn ();
+    }
+
+  /* We probably should check type of the insn so that we do not create
+     inconsistent cfg.  It is checked in verify_flow_info anyway, so do not
+     bother.  */
+  if (insn == BB_END (bb))
+    emit_note_after (NOTE_INSN_DELETED, insn);
 
   /* Create the new basic block.  */
   new_bb = create_basic_block (NEXT_INSN (insn), BB_END (bb), bb);
@@ -2711,6 +2723,18 @@ cfg_layout_split_edge (edge e)
   new_bb->count = e->count;
   new_bb->frequency = EDGE_FREQUENCY (e);
 
+  /* ??? This info is likely going to be out of date very soon, but we must
+     create it to avoid getting an ICE later.  */
+  if (e->dest->global_live_at_start)
+    {
+      new_bb->global_live_at_start = OBSTACK_ALLOC_REG_SET (&flow_obstack);
+      new_bb->global_live_at_end = OBSTACK_ALLOC_REG_SET (&flow_obstack);
+      COPY_REG_SET (new_bb->global_live_at_start,
+                   e->dest->global_live_at_start);
+      COPY_REG_SET (new_bb->global_live_at_end,
+                   e->dest->global_live_at_start);
+    }
+
   new_e = make_edge (new_bb, e->dest, EDGE_FALLTHRU);
   new_e->probability = REG_BR_PROB_BASE;
   new_e->count = e->count;
index 7371da9..e860b4f 100644 (file)
@@ -3715,27 +3715,28 @@ combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int last,
       temp = simplify_unary_operation (code, mode, XEXP (x, 0), op0_mode);
       break;
     case '<':
-      {
-       enum machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
-       if (cmp_mode == VOIDmode)
-         {
-           cmp_mode = GET_MODE (XEXP (x, 1));
-           if (cmp_mode == VOIDmode)
-             cmp_mode = op0_mode;
-         }
-       temp = simplify_relational_operation (code, cmp_mode,
-                                             XEXP (x, 0), XEXP (x, 1));
-      }
-#ifdef FLOAT_STORE_FLAG_VALUE
-      if (temp != 0 && GET_MODE_CLASS (mode) == MODE_FLOAT)
+      if (! VECTOR_MODE_P (mode))
        {
-         if (temp == const0_rtx)
-           temp = CONST0_RTX (mode);
-         else
-           temp = CONST_DOUBLE_FROM_REAL_VALUE (FLOAT_STORE_FLAG_VALUE (mode),
-                                                mode);
-       }
+         enum machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
+         if (cmp_mode == VOIDmode)
+           {
+             cmp_mode = GET_MODE (XEXP (x, 1));
+             if (cmp_mode == VOIDmode)
+               cmp_mode = op0_mode;
+           }
+         temp = simplify_relational_operation (code, cmp_mode,
+                                               XEXP (x, 0), XEXP (x, 1));
+#ifdef FLOAT_STORE_FLAG_VALUE
+         if (temp != 0 && GET_MODE_CLASS (mode) == MODE_FLOAT)
+           {
+             if (temp == const0_rtx)
+               temp = CONST0_RTX (mode);
+             else
+               temp = CONST_DOUBLE_FROM_REAL_VALUE
+                        (FLOAT_STORE_FLAG_VALUE (mode), mode);
+           }
 #endif
+       }
       break;
     case 'c':
     case '2':
@@ -10019,13 +10020,8 @@ gen_lowpart_for_combine (enum machine_mode mode, rtx x)
 
   result = gen_lowpart_common (mode, x);
 #ifdef CANNOT_CHANGE_MODE_CLASS
-  if (result != 0
-      && GET_CODE (result) == SUBREG
-      && GET_CODE (SUBREG_REG (result)) == REG
-      && REGNO (SUBREG_REG (result)) >= FIRST_PSEUDO_REGISTER)
-    bitmap_set_bit (&subregs_of_mode, REGNO (SUBREG_REG (result))
-                                     * MAX_MACHINE_MODE
-                                     + GET_MODE (result));
+  if (result != 0 && GET_CODE (result) == SUBREG)
+    record_subregs_of_mode (result);
 #endif
 
   if (result)
@@ -10103,7 +10099,7 @@ gen_binary (enum rtx_code code, enum machine_mode mode, rtx op0, rtx op1)
     return op0;
   else if (GET_CODE (op1) == CLOBBER)
     return op1;
-  
+
   if (GET_RTX_CLASS (code) == 'c'
       && swap_commutative_operands_p (op0, op1))
     tem = op0, op0 = op1, op1 = tem;
@@ -12658,8 +12654,11 @@ distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2)
 
                  /* If the register is being set at TEM, see if that is all
                     TEM is doing.  If so, delete TEM.  Otherwise, make this
-                    into a REG_UNUSED note instead.  */
-                 if (reg_set_p (XEXP (note, 0), PATTERN (tem)))
+                    into a REG_UNUSED note instead.  Don't delete sets to
+                    global register vars.  */
+                 if ((REGNO (XEXP (note, 0)) >= FIRST_PSEUDO_REGISTER
+                      || !global_regs[REGNO (XEXP (note, 0))])
+                     && reg_set_p (XEXP (note, 0), PATTERN (tem)))
                    {
                      rtx set = single_set (tem);
                      rtx inner_dest = 0;
index 261c8d2..20d1b75 100644 (file)
@@ -28,7 +28,7 @@ Display this information
 
 -param
 Common Separate
---param <param>=<value>        Set paramter <param> to value.  See below for a complete list of parameters
+--param <param>=<value>        Set parameter <param> to value.  See below for a complete list of parameters
 
 -target-help
 Common
index abe450a..2869063 100644 (file)
@@ -34,7 +34,7 @@
 #include <xmmintrin.h>
 
 /* SSE2 */
-typedef int __v2df __attribute__ ((mode (V2DF)));
+typedef double __v2df __attribute__ ((mode (V2DF)));
 typedef int __v2di __attribute__ ((mode (V2DI)));
 typedef int __v4si __attribute__ ((mode (V4SI)));
 typedef int __v8hi __attribute__ ((mode (V8HI)));
index 7dfe2d6..50794c3 100644 (file)
@@ -1252,10 +1252,16 @@ override_options (void)
        ix86_tune = processor_alias_table[i].processor;
        if (TARGET_64BIT && !(processor_alias_table[i].flags & PTA_64BIT))
          error ("CPU you selected does not support x86-64 instruction set");
+
+       /* Intel CPUs have always interpreted SSE prefetch instructions as
+          NOPs; so, we can enable SSE prefetch instructions even when
+          -mtune (rather than -march) points us to a processor that has them.
+          However, the VIA C3 gives a SIGILL, so we only do that for i686 and
+          higher processors.  */
+       if (TARGET_CMOVE && (processor_alias_table[i].flags & PTA_PREFETCH_SSE))
+         x86_prefetch_sse = true;
        break;
       }
-  if (processor_alias_table[i].flags & PTA_PREFETCH_SSE)
-    x86_prefetch_sse = true;
   if (i == pta_size)
     error ("bad value (%s) for -mtune= switch", ix86_tune_string);
 
@@ -5769,45 +5775,40 @@ ix86_find_base_term (rtx x)
 bool
 legitimate_constant_p (rtx x)
 {
-  rtx inner;
-
   switch (GET_CODE (x))
     {
-    case SYMBOL_REF:
-      /* TLS symbols are not constant.  */
-      if (tls_symbolic_operand (x, Pmode))
-       return false;
-      break;
-
     case CONST:
-      inner = XEXP (x, 0);
-
-      /* Offsets of TLS symbols are never valid.
-        Discourage CSE from creating them.  */
-      if (GET_CODE (inner) == PLUS
-         && tls_symbolic_operand (XEXP (inner, 0), Pmode))
-       return false;
+      x = XEXP (x, 0);
 
-      if (GET_CODE (inner) == PLUS
-         || GET_CODE (inner) == MINUS)
+      if (GET_CODE (x) == PLUS)
        {
-         if (GET_CODE (XEXP (inner, 1)) != CONST_INT)
+         if (GET_CODE (XEXP (x, 1)) != CONST_INT)
            return false;
-         inner = XEXP (inner, 0);
+         x = XEXP (x, 0);
        }
 
       /* Only some unspecs are valid as "constants".  */
-      if (GET_CODE (inner) == UNSPEC)
-       switch (XINT (inner, 1))
+      if (GET_CODE (x) == UNSPEC)
+       switch (XINT (x, 1))
          {
          case UNSPEC_TPOFF:
          case UNSPEC_NTPOFF:
-           return local_exec_symbolic_operand (XVECEXP (inner, 0, 0), Pmode);
+           return local_exec_symbolic_operand (XVECEXP (x, 0, 0), Pmode);
          case UNSPEC_DTPOFF:
-           return local_dynamic_symbolic_operand (XVECEXP (inner, 0, 0), Pmode);
+           return local_dynamic_symbolic_operand (XVECEXP (x, 0, 0), Pmode);
          default:
            return false;
          }
+
+      /* We must have drilled down to a symbol.  */
+      if (!symbolic_operand (x, Pmode))
+       return false;
+      /* FALLTHRU */
+
+    case SYMBOL_REF:
+      /* TLS symbols are never valid.  */
+      if (tls_symbolic_operand (x, Pmode))
+       return false;
       break;
 
     default:
@@ -12781,7 +12782,7 @@ x86_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
        abort ();
     }
 
-#ifdef TRANSFER_FROM_TRAMPOLINE
+#ifdef ENABLE_EXECUTE_STACK
   emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__enable_execute_stack"),
                     LCT_NORMAL, VOIDmode, 1, tramp, Pmode);
 #endif
index 90e1a95..86ea88c 100644 (file)
@@ -63,7 +63,6 @@
    (UNSPEC_INDNTPOFF           8)
 
    ; Prologue support
-   (UNSPEC_STACK_PROBE         10)
    (UNSPEC_STACK_ALLOC         11)
    (UNSPEC_SET_GOT             12)
    (UNSPEC_SSE_PROLOGUE_SAVE   13)
 
 (define_constants
   [(UNSPECV_BLOCKAGE           0)
+   (UNSPECV_STACK_PROBE                10)
    (UNSPECV_EH_RETURN          13)
    (UNSPECV_EMMS               31)
    (UNSPECV_LDMXCSR            37)
     }
 }
   [(set (attr "type")
-     (if_then_else (match_operand:QI 2 "incdec_operand" "")
+     (if_then_else (match_operand:QI 1 "incdec_operand" "")
        (const_string "incdec")
        (const_string "alu1")))
    (set_attr "mode" "QI")])
 })
 
 (define_insn "allocate_stack_worker_1"
-  [(unspec:SI [(match_operand:SI 0 "register_operand" "a")] UNSPEC_STACK_PROBE)
+  [(unspec_volatile:SI [(match_operand:SI 0 "register_operand" "a")]
+    UNSPECV_STACK_PROBE)
    (set (reg:SI 7) (minus:SI (reg:SI 7) (match_dup 0)))
    (clobber (match_scratch:SI 1 "=0"))
    (clobber (reg:CC 17))]
    (set_attr "length" "5")])
 
 (define_expand "allocate_stack_worker_postreload"
-  [(parallel [(unspec:SI [(match_operand:SI 0 "register_operand" "a")]
-                          UNSPEC_STACK_PROBE)
+  [(parallel [(unspec_volatile:SI [(match_operand:SI 0 "register_operand" "a")]
+                                   UNSPECV_STACK_PROBE)
              (set (reg:SI 7) (minus:SI (reg:SI 7) (match_dup 0)))
              (clobber (match_dup 0))
              (clobber (reg:CC 17))])]
   "")
 
 (define_insn "allocate_stack_worker_rex64"
-  [(unspec:DI [(match_operand:DI 0 "register_operand" "a")] UNSPEC_STACK_PROBE)
+  [(unspec_volatile:DI [(match_operand:DI 0 "register_operand" "a")]
+    UNSPECV_STACK_PROBE)
    (set (reg:DI 7) (minus:DI (reg:DI 7) (match_dup 0)))
    (clobber (match_scratch:DI 1 "=0"))
    (clobber (reg:CC 17))]
    (set_attr "length" "5")])
 
 (define_expand "allocate_stack_worker_rex64_postreload"
-  [(parallel [(unspec:DI [(match_operand:DI 0 "register_operand" "a")]
-                          UNSPEC_STACK_PROBE)
+  [(parallel [(unspec_volatile:DI [(match_operand:DI 0 "register_operand" "a")]
+                                   UNSPECV_STACK_PROBE)
              (set (reg:DI 7) (minus:DI (reg:DI 7) (match_dup 0)))
              (clobber (match_dup 0))
              (clobber (reg:CC 17))])]
 
 (define_insn "movv16qi_internal"
   [(set (match_operand:V16QI 0 "nonimmediate_operand" "=x,x,m")
-       (match_operand:V16QI 1 "nonimmediate_operand" "C,xm,x"))]
+       (match_operand:V16QI 1 "vector_move_operand" "C,xm,x"))]
   "TARGET_SSE2
    && (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM)"
 {
index 1bc8878..921806f 100644 (file)
 #include <mmintrin.h>
 
 /* The data type intended for user use.  */
-typedef int __m128 __attribute__ ((__mode__(__V4SF__)));
+typedef float __m128 __attribute__ ((__mode__(__V4SF__)));
 
 /* Internal data types for implementing the intrinsics.  */
-typedef int __v4sf __attribute__ ((__mode__(__V4SF__)));
+typedef float __v4sf __attribute__ ((__mode__(__V4SF__)));
 
 /* Create a selector for use with the SHUFPS instruction.  */
 #define _MM_SHUFFLE(fp3,fp2,fp1,fp0) \
index e8e8a5f..c4a09ba 100644 (file)
@@ -109,6 +109,8 @@ static void add_candidates (tree, tree, tree, bool, tree, tree,
                            int, struct z_candidate **);
 static tree merge_conversion_sequences (tree, tree);
 static bool magic_varargs_p (tree);
+static tree build_temp (tree, tree, int, void (**)(const char *, ...));
+static void check_constructor_callable (tree, tree);
 
 tree
 build_vfield_ref (tree datum, tree type)
@@ -371,6 +373,9 @@ struct z_candidate GTY(()) {
 #define USER_CONV_CAND(NODE) WRAPPER_ZC (TREE_OPERAND (NODE, 1))
 #define USER_CONV_FN(NODE) (USER_CONV_CAND (NODE)->fn)
 
+/* Returns true iff T is a null pointer constant in the sense of
+   [conv.ptr].  */
+
 bool
 null_ptr_cst_p (tree t)
 {
@@ -378,6 +383,8 @@ null_ptr_cst_p (tree t)
 
      A null pointer constant is an integral constant expression
      (_expr.const_) rvalue of integer type that evaluates to zero.  */
+  if (DECL_INTEGRAL_CONSTANT_VAR_P (t))
+    t = decl_constant_value (t);
   if (t == null_node
       || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t)))
     return true;
@@ -571,6 +578,8 @@ standard_conversion (tree to, tree from, tree expr)
                                        TYPE_PTRMEM_POINTED_TO_TYPE (from));
              conv = build_conv (PMEM_CONV, from, conv);
            }
+         else if (!same_type_p (fbase, tbase))
+           return NULL;
        }
       else if (IS_AGGR_TYPE (TREE_TYPE (from))
               && IS_AGGR_TYPE (TREE_TYPE (to))
@@ -1052,7 +1061,8 @@ reference_binding (tree rto, tree rfrom, tree expr, int flags)
     {
       conv = build1 (IDENTITY_CONV, from, expr);
       conv = direct_reference_binding (rto, conv);
-      CHECK_COPY_CONSTRUCTOR_P (TREE_OPERAND (conv, 0)) = 1;
+      if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
+       CHECK_COPY_CONSTRUCTOR_P (TREE_OPERAND (conv, 0)) = 1;
       return conv;
     }
 
@@ -3857,6 +3867,20 @@ enforce_access (tree basetype_path, tree decl)
   return true;
 }
 
+/* Check that a callable constructor to initialize a temporary of
+   TYPE from an EXPR exists.  */
+
+static void
+check_constructor_callable (tree type, tree expr)
+{
+  build_special_member_call (NULL_TREE,
+                            complete_ctor_identifier,
+                            build_tree_list (NULL_TREE, expr), 
+                            TYPE_BINFO (type),
+                            LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
+                            | LOOKUP_CONSTRUCTOR_CALLABLE);
+}
+
 /* Initialize a temporary of type TYPE with EXPR.  The FLAGS are a
    bitwise or of LOOKUP_* values.  If any errors are warnings are
    generated, set *DIAGNOSTIC_FN to "error" or "warning",
@@ -3868,9 +3892,9 @@ build_temp (tree expr, tree type, int flags,
            void (**diagnostic_fn)(const char *, ...))
 {
   int savew, savee;
-
+  
   savew = warningcount, savee = errorcount;
-  expr = build_special_member_call (NULL_TREE, 
+  expr = build_special_member_call (NULL_TREE,
                                    complete_ctor_identifier,
                                    build_tree_list (NULL_TREE, expr), 
                                    TYPE_BINFO (type),
@@ -4003,13 +4027,9 @@ convert_like_real (tree convs, tree expr, tree fn, int argnum, int inner,
          && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
        expr = decl_constant_value (expr);
       if (CHECK_COPY_CONSTRUCTOR_P (convs))
-       /* Generate a temporary copy purely to generate the required
-          diagnostics.  */
-       build_temp
-         (build_dummy_object
-          (build_qualified_type (totype, TYPE_QUAL_CONST)),
-          totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING, &diagnostic_fn);
-       return expr;
+       check_constructor_callable (totype, expr);
+      
+      return expr;
     case AMBIG_CONV:
       /* Call build_user_type_conversion again for the error.  */
       return build_user_type_conversion
@@ -4037,12 +4057,7 @@ convert_like_real (tree convs, tree expr, tree fn, int argnum, int inner,
          /* We are going to bind a reference directly to a base-class
             subobject of EXPR.  */
          if (CHECK_COPY_CONSTRUCTOR_P (convs))
-           /* Generate a temporary copy purely to generate the required
-              diagnostics.  */
-           build_temp (build_dummy_object (TREE_TYPE (expr)),
-                       TREE_TYPE (expr),
-                       LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
-                       &diagnostic_fn);
+           check_constructor_callable (TREE_TYPE (expr), expr);
          /* Build an expression for `*((base*) &expr)'.  */
          expr = build_unary_op (ADDR_EXPR, expr, 0);
          expr = perform_implicit_conversion (build_pointer_type (totype), 
@@ -6161,14 +6176,8 @@ initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
         remember that the conversion was required.  */
       if (TREE_CODE (conv) == BASE_CONV && !NEED_TEMPORARY_P (conv))
        {
-         void (*diagnostic_fn) (const char *, ...);
          if (CHECK_COPY_CONSTRUCTOR_P (conv))
-           /* Generate a temporary copy purely to generate the required
-              diagnostics.  */
-           build_temp (build_dummy_object (TREE_TYPE (expr)),
-                       TREE_TYPE (expr),
-                       LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
-                       &diagnostic_fn);
+           check_constructor_callable (TREE_TYPE (expr), expr);
          base_conv_type = TREE_TYPE (conv);
          conv = TREE_OPERAND (conv, 0);
        }
index 9fa7f26..e4deb01 100644 (file)
@@ -1847,6 +1847,36 @@ base_derived_from (tree derived, tree base)
   return false;
 }
 
+typedef struct count_depth_data {
+  /* The depth of the current subobject, with "1" as the depth of the
+     most derived object in the hierarchy.  */
+  size_t depth;
+  /* The maximum depth found so far.  */
+  size_t max_depth;
+} count_depth_data;
+
+/* Called from find_final_overrider via dfs_walk.  */
+
+static tree
+dfs_depth_post (tree binfo ATTRIBUTE_UNUSED, void *data)
+{
+  count_depth_data *cd = (count_depth_data *) data;
+  if (cd->depth > cd->max_depth)
+    cd->max_depth = cd->depth;
+  cd->depth--;
+  return NULL_TREE;
+}
+
+/* Called from find_final_overrider via dfs_walk.  */
+
+static tree
+dfs_depth_q (tree derived, int i, void *data)
+{
+  count_depth_data *cd = (count_depth_data *) data;
+  cd->depth++;
+  return BINFO_BASETYPE (derived, i);
+}
+
 typedef struct find_final_overrider_data_s {
   /* The function for which we are trying to find a final overrider.  */
   tree fn;
@@ -1856,70 +1886,74 @@ typedef struct find_final_overrider_data_s {
   tree most_derived_type;
   /* The candidate overriders.  */
   tree candidates;
-  /* Binfos which inherited virtually on the current path.  */
-  tree vpath;
+  /* Each entry in this array is the next-most-derived class for a
+     virtual base class along the current path.  */
+  tree *vpath_list;
+  /* A pointer one past the top of the VPATH_LIST.  */
+  tree *vpath;
 } find_final_overrider_data;
 
-/* Called from find_final_overrider via dfs_walk.  */
+/* Add the overrider along the current path to FFOD->CANDIDATES.
+   Returns true if an overrider was found; false otherwise.  */
 
-static tree
-dfs_find_final_overrider (tree binfo, void* data)
+static bool
+dfs_find_final_overrider_1 (tree binfo, 
+                           tree *vpath, 
+                           find_final_overrider_data *ffod)
 {
-  find_final_overrider_data *ffod = (find_final_overrider_data *) data;
-
-  if (binfo == ffod->declaring_base)
+  tree method;
+         
+  /* If BINFO is not the most derived type, try a more derived class.
+     A definition there will overrider a definition here.  */
+  if (!same_type_p (BINFO_TYPE (binfo), ffod->most_derived_type))
     {
-      /* We've found a path to the declaring base.  Walk the path from
-        derived to base, looking for an overrider for FN.  */
-      tree path, probe, vpath;
+      tree derived;
 
-      /* Build the path, using the inheritance chain and record of
-        virtual inheritance.  */
-      for (path = NULL_TREE, probe = binfo, vpath = ffod->vpath;;)
+      if (TREE_VIA_VIRTUAL (binfo))
+       derived = *--vpath;
+      else
+       derived = BINFO_INHERITANCE_CHAIN (binfo);
+      if (dfs_find_final_overrider_1 (derived, vpath, ffod))
+       return true;
+    }
+
+  method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
+  if (method)
+    {
+      tree *candidate = &ffod->candidates;
+      
+      /* Remove any candidates overridden by this new function.  */
+      while (*candidate)
        {
-         path = tree_cons (NULL_TREE, probe, path);
-         if (same_type_p (BINFO_TYPE (probe), ffod->most_derived_type))
-           break;
-         if (TREE_VIA_VIRTUAL (probe))
-           {
-             probe = TREE_VALUE (vpath);
-             vpath = TREE_CHAIN (vpath);
-           }
+         /* If *CANDIDATE overrides METHOD, then METHOD
+            cannot override anything else on the list.  */
+         if (base_derived_from (TREE_VALUE (*candidate), binfo))
+           return true;
+         /* If METHOD overrides *CANDIDATE, remove *CANDIDATE.  */
+         if (base_derived_from (binfo, TREE_VALUE (*candidate)))
+           *candidate = TREE_CHAIN (*candidate);
          else
-           probe = BINFO_INHERITANCE_CHAIN (probe);
-       }
-      /* Now walk path, looking for overrides.  */
-      for (; path; path = TREE_CHAIN (path))
-       {
-         tree method = look_for_overrides_here
-           (BINFO_TYPE (TREE_VALUE (path)), ffod->fn);
-         
-         if (method)
-           {
-             tree *candidate = &ffod->candidates;
-             path = TREE_VALUE (path);
-
-             /* Remove any candidates overridden by this new function.  */
-             while (*candidate)
-               {
-                 /* If *CANDIDATE overrides METHOD, then METHOD
-                    cannot override anything else on the list.  */
-                 if (base_derived_from (TREE_VALUE (*candidate), path))
-                   return NULL_TREE;
-                 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE.  */
-                 if (base_derived_from (path, TREE_VALUE (*candidate)))
-                   *candidate = TREE_CHAIN (*candidate);
-                 else
-                   candidate = &TREE_CHAIN (*candidate);
-               }
-             
-             /* Add the new function.  */
-             ffod->candidates = tree_cons (method, path, ffod->candidates);
-             break;
-           }
+           candidate = &TREE_CHAIN (*candidate);
        }
+      
+      /* Add the new function.  */
+      ffod->candidates = tree_cons (method, binfo, ffod->candidates);
+      return true;
     }
 
+  return false;
+}
+
+/* Called from find_final_overrider via dfs_walk.  */
+
+static tree
+dfs_find_final_overrider (tree binfo, void* data)
+{
+  find_final_overrider_data *ffod = (find_final_overrider_data *) data;
+
+  if (binfo == ffod->declaring_base)
+    dfs_find_final_overrider_1 (binfo, ffod->vpath, ffod);
+
   return NULL_TREE;
 }
 
@@ -1930,7 +1964,7 @@ dfs_find_final_overrider_q (tree derived, int ix, void *data)
   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
 
   if (TREE_VIA_VIRTUAL (binfo))
-    ffod->vpath = tree_cons (NULL_TREE, derived, ffod->vpath);
+    *ffod->vpath++ = derived;
   
   return binfo;
 }
@@ -1940,8 +1974,8 @@ dfs_find_final_overrider_post (tree binfo, void *data)
 {
   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
 
-  if (TREE_VIA_VIRTUAL (binfo) && TREE_CHAIN (ffod->vpath))
-    ffod->vpath = TREE_CHAIN (ffod->vpath);
+  if (TREE_VIA_VIRTUAL (binfo))
+    ffod->vpath--;
   
   return NULL_TREE;
 }
@@ -1955,6 +1989,7 @@ static tree
 find_final_overrider (tree derived, tree binfo, tree fn)
 {
   find_final_overrider_data ffod;
+  count_depth_data cd;
 
   /* Getting this right is a little tricky.  This is valid:
 
@@ -1976,12 +2011,18 @@ find_final_overrider (tree derived, tree binfo, tree fn)
      different overriders along any two, then there is a problem.  */
   if (DECL_THUNK_P (fn))
     fn = THUNK_TARGET (fn);
-  
+
+  /* Determine the depth of the hierarchy.  */
+  cd.depth = 0;
+  cd.max_depth = 0;
+  dfs_walk (derived, dfs_depth_post, dfs_depth_q, &cd);
+
   ffod.fn = fn;
   ffod.declaring_base = binfo;
   ffod.most_derived_type = BINFO_TYPE (derived);
   ffod.candidates = NULL_TREE;
-  ffod.vpath = NULL_TREE;
+  ffod.vpath_list = (tree *) xcalloc (cd.max_depth, sizeof (tree));
+  ffod.vpath = ffod.vpath_list;
 
   dfs_walk_real (derived,
                 dfs_find_final_overrider,
@@ -1989,6 +2030,8 @@ find_final_overrider (tree derived, tree binfo, tree fn)
                 dfs_find_final_overrider_q,
                 &ffod);
 
+  free (ffod.vpath_list);
+
   /* If there was no winner, issue an error message.  */
   if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
     {
index bf051ea..b2fec24 100644 (file)
@@ -1899,6 +1899,23 @@ struct lang_decl GTY(())
 #define DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P(NODE) \
   (TREE_LANG_FLAG_2 (VAR_DECL_CHECK (NODE)))
 
+/* Nonzero for a VAR_DECL that can be used in an integral constant
+   expression.    
+
+      [expr.const]
+
+      An integral constant-expression can only involve ... const
+      variables of static or enumeration types initialized with
+      constant expressions ...
+  
+   The standard does not require that the expression be non-volatile.
+   G++ implements the proposed correction in DR 457.  */
+#define DECL_INTEGRAL_CONSTANT_VAR_P(NODE)             \
+  (TREE_CODE (NODE) == VAR_DECL                                \
+   && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (NODE))  \
+   && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (NODE))        \
+   && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (NODE))
+
 /* Nonzero if the DECL was initialized in the class definition itself,
    rather than outside the class.  This is used for both static member
    VAR_DECLS, and FUNTION_DECLS that are defined in the class.  */
@@ -3332,20 +3349,21 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG };
    LOOKUP_PREFER_NAMESPACES means not to accept objects, and possibly types.
    LOOKUP_PREFER_BOTH means class-or-namespace-name.  */
 
-#define LOOKUP_PROTECT (1)
-#define LOOKUP_COMPLAIN (2)
-#define LOOKUP_NORMAL (3)
-#define LOOKUP_NONVIRTUAL (8)
-#define LOOKUP_GLOBAL (16)
-#define LOOKUP_SPECULATIVELY (64)
-#define LOOKUP_ONLYCONVERTING (128)
-#define DIRECT_BIND (256)
-#define LOOKUP_NO_CONVERSION (512)
-#define LOOKUP_DESTRUCTOR (512)
-#define LOOKUP_NO_TEMP_BIND (1024)
-#define LOOKUP_PREFER_TYPES (2048)
-#define LOOKUP_PREFER_NAMESPACES (4096)
-#define LOOKUP_PREFER_BOTH (6144)
+#define LOOKUP_PROTECT (1 << 0)
+#define LOOKUP_COMPLAIN (1 << 1)
+#define LOOKUP_NORMAL (LOOKUP_PROTECT | LOOKUP_COMPLAIN)
+#define LOOKUP_NONVIRTUAL (1 << 2)
+#define LOOKUP_GLOBAL (1 << 3)
+#define LOOKUP_SPECULATIVELY (1 << 4)
+#define LOOKUP_ONLYCONVERTING (1 << 5)
+#define DIRECT_BIND (1 << 6)
+#define LOOKUP_NO_CONVERSION (1 << 7)
+#define LOOKUP_DESTRUCTOR (1 << 8)
+#define LOOKUP_NO_TEMP_BIND (1 << 9)
+#define LOOKUP_PREFER_TYPES (1 << 10)
+#define LOOKUP_PREFER_NAMESPACES (1 << 11)
+#define LOOKUP_PREFER_BOTH (LOOKUP_PREFER_TYPES | LOOKUP_PREFER_NAMESPACES)
+#define LOOKUP_CONSTRUCTOR_CALLABLE (1 << 12)
 
 #define LOOKUP_NAMESPACES_ONLY(F)  \
   (((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES))
@@ -3710,6 +3728,7 @@ extern tree cp_fname_init                 (const char *, tree *);
 extern tree check_elaborated_type_specifier     (enum tag_types, tree, bool);
 extern tree cxx_builtin_type_decls              (void);
 extern void warn_extern_redeclared_static (tree, tree);
+extern tree check_var_type                      (tree, tree);
 
 extern bool have_extern_spec;
 
@@ -3996,6 +4015,7 @@ extern tree adjust_result_of_qualified_name_lookup
                                                 (tree, tree, tree);
 extern tree copied_binfo                       (tree, tree);
 extern tree original_binfo                     (tree, tree);
+extern int shared_member_p                      (tree);
 
 /* in semantics.c */
 extern void push_deferring_access_checks       (deferring_kind);
index 53c677a..e4d304a 100644 (file)
@@ -177,6 +177,10 @@ pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
       pp_cxx_template_id (pp, t);
       break;
 
+    case BASELINK:
+      pp_cxx_unqualified_id (pp, BASELINK_FUNCTIONS (t));
+      break;
+
     case RECORD_TYPE:
     case UNION_TYPE:
     case ENUMERAL_TYPE:
index eb34d39..a19c501 100644 (file)
@@ -119,6 +119,7 @@ static void initialize_local_var (tree, tree);
 static void expand_static_init (tree, tree);
 static tree next_initializable_field (tree);
 static tree reshape_init (tree, tree *);
+static bool reshape_init_array (tree, tree, tree *, tree);
 static tree build_typename_type (tree, tree, tree);
 
 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
@@ -1410,19 +1411,32 @@ duplicate_decls (tree newdecl, tree olddecl)
     /* One of the declarations is a template instantiation, and the
        other is not a template at all.  That's OK.  */
     return NULL_TREE;
-  else if (TREE_CODE (newdecl) == NAMESPACE_DECL
-           && DECL_NAMESPACE_ALIAS (newdecl)
-           && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
-    /* In [namespace.alias] we have:
-
-        In a declarative region, a namespace-alias-definition can be
-        used to redefine a namespace-alias declared in that declarative
-        region to refer only to the namespace to which it already
-        refers.  
-
-      Therefore, if we encounter a second alias directive for the same
-      alias, we can just ignore the second directive.  */
-    return olddecl;
+  else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
+    {
+      /* In [namespace.alias] we have:
+        
+           In a declarative region, a namespace-alias-definition can be
+          used to redefine a namespace-alias declared in that declarative
+          region to refer only to the namespace to which it already
+          refers.
+          
+        Therefore, if we encounter a second alias directive for the same
+        alias, we can just ignore the second directive.  */
+      if (DECL_NAMESPACE_ALIAS (newdecl)
+         && (DECL_NAMESPACE_ALIAS (newdecl) 
+             == DECL_NAMESPACE_ALIAS (olddecl)))
+       return olddecl;
+      /* [namespace.alias]
+
+         A namespace-name or namespace-alias shall not be declared as
+        the name of any other entity in the same declarative region.
+        A namespace-name defined at global scope shall not be
+        declared as the name of any other entity in any glogal scope
+        of the program.  */
+      error ("declaration of `namespace %D' conflicts with", newdecl);
+      cp_error_at ("previous declaration of `namespace %D' here", olddecl);
+      return error_mark_node;
+    }
   else
     {
       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
@@ -4183,6 +4197,70 @@ next_initializable_field (tree field)
   return field;
 }
 
+/* Subroutine of reshape_init. Reshape the constructor for an array. INITP
+   is the pointer to the old constructor list (to the CONSTRUCTOR_ELTS of
+   the CONSTRUCTOR we are processing), while NEW_INIT is the CONSTRUCTOR we
+   are building.
+   ELT_TYPE is the element type of the array. MAX_INDEX is an INTEGER_CST
+   representing the size of the array minus one (the maximum index), or
+   NULL_TREE if the array was declared without specifying the size.  */
+
+static bool
+reshape_init_array (tree elt_type, tree max_index,
+                   tree *initp, tree new_init)
+{
+  bool sized_array_p = (max_index != NULL_TREE);
+  HOST_WIDE_INT max_index_cst = 0;
+  HOST_WIDE_INT index;
+
+  if (sized_array_p)
+    /* HWI is either 32bit or 64bit, so it must be enough to represent the
+       array size.  */
+    max_index_cst = tree_low_cst (max_index, 1);
+
+  /* Loop until there are no more initializers.  */
+  for (index = 0;
+       *initp && (!sized_array_p || index <= max_index_cst);
+       ++index)
+    {
+      tree element_init;
+      tree designated_index;
+
+      element_init = reshape_init (elt_type, initp);
+      if (element_init == error_mark_node)
+       return false;
+      TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
+      CONSTRUCTOR_ELTS (new_init) = element_init;
+      designated_index = TREE_PURPOSE (element_init);
+      if (designated_index)
+       {
+         /* Handle array designated initializers (GNU extension).  */
+         if (TREE_CODE (designated_index) == IDENTIFIER_NODE)
+           {
+             error ("name `%D' used in a GNU-style designated "
+                   "initializer for an array", designated_index);
+             TREE_PURPOSE (element_init) = NULL_TREE;
+           }
+         else
+           {
+             if (TREE_CODE (designated_index) != INTEGER_CST)
+               abort ();
+             if (sized_array_p
+                 && tree_int_cst_lt (max_index, designated_index))
+               {
+                 error ("Designated initializer `%E' larger than array "
+                        "size", designated_index);
+                 TREE_PURPOSE (element_init) = NULL_TREE;
+               }
+             else
+               index = tree_low_cst (designated_index, 1);
+           }
+       }
+    }
+
+  return true;
+}
+
 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
    brace-enclosed aggregate initializer.
 
@@ -4351,38 +4429,15 @@ reshape_init (tree type, tree *initp)
        }
       else if ((TREE_CODE (type) == ARRAY_TYPE)|| (TREE_CODE (type) == VECTOR_TYPE))
        {
-         tree index;
          tree max_index;
 
          /* If the bound of the array is known, take no more initializers
             than are allowed.  */
          max_index = ((TYPE_DOMAIN (type) && (TREE_CODE (type) == ARRAY_TYPE))
                       ? array_type_nelts (type) : NULL_TREE);
-         /* Loop through the array elements, gathering initializers.  */
-         for (index = size_zero_node;
-              *initp && (!max_index || !tree_int_cst_lt (max_index, index));
-              index = size_binop (PLUS_EXPR, index, size_one_node))
-           {
-             tree element_init;
-
-             element_init = reshape_init (TREE_TYPE (type), initp);
-             if (element_init == error_mark_node)
-               return error_mark_node;
-             TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
-             CONSTRUCTOR_ELTS (new_init) = element_init;
-             if (TREE_PURPOSE (element_init))
-               {
-                 tree next_index = TREE_PURPOSE (element_init);
-                 if (TREE_CODE (next_index) == IDENTIFIER_NODE)
-                   {
-                     error ("name `%D' used in a GNU-style designated "
-                            "initializer for an array", next_index);
-                     TREE_PURPOSE (element_init) = NULL_TREE;
-                   }
-                 else
-                   index = next_index;
-               }
-           }
+         if (!reshape_init_array (TREE_TYPE (type), max_index,
+                                  initp, new_init))
+           return error_mark_node;
        }
       else
        abort ();
@@ -4723,6 +4778,7 @@ cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
   tree cleanup;
   const char *asmspec = NULL;
   int was_readonly = 0;
+  bool var_definition_p = false;
 
   if (decl == error_mark_node)
     return;
@@ -4875,6 +4931,11 @@ cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
          /* Remember that the initialization for this variable has
             taken place.  */
          DECL_INITIALIZED_P (decl) = 1;
+         /* This declaration is the definition of this variable,
+            unless we are initializing a static data member within
+            the class specifier.  */
+         if (!DECL_EXTERNAL (decl))
+           var_definition_p = true;
        }
       /* If the variable has an array type, lay out the type, even if
         there is no initializer.  It is valid to index through the
@@ -4949,8 +5010,16 @@ cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
                initialize_local_var (decl, init);
            }
 
-         if (TREE_STATIC (decl))
-           expand_static_init (decl, init);
+         /* If a variable is defined, and then a subsequent
+            definintion with external linkage is encountered, we will
+            get here twice for the same variable.  We want to avoid
+            calling expand_static_init more than once.  For variables
+            that are not static data members, we can call
+            expand_static_init only when we actually process the
+            initializer.  It is not legal to redeclare a static data
+            member, so this issue does not arise in that case.  */
+         if (var_definition_p && TREE_STATIC (decl))
+           expand_static_init (decl, init); 
        }
     finish_end0:
 
@@ -6317,6 +6386,32 @@ check_special_function_return_type (special_function_kind sfk,
   return type;
 }
 
+/* A variable or data member (whose unqualified name is IDENTIFIER)
+   has been declared with the indicated TYPE.  If the TYPE is not
+   acceptable, issue an error message and return a type to use for
+   error-recovery purposes. */
+
+tree
+check_var_type (tree identifier, tree type)
+{
+  if (VOID_TYPE_P (type))
+    {
+      if (!identifier)
+       error ("unnamed variable or field declared void");
+      else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
+       {
+         if (IDENTIFIER_OPNAME_P (identifier))
+           abort ();
+         error ("variable or field `%E' declared void", identifier);
+       }
+      else
+       error ("variable or field declared void");
+      type = integer_type_node;
+    }
+  
+  return type;
+}
+
 /* Given declspecs and a declarator (abstract or otherwise), determine
    the name and type of the object declared and construct a DECL node
    for it.
@@ -8016,30 +8111,25 @@ grokdeclarator (tree declarator,
           && ! bitfield)
     {
       error ("abstract declarator `%T' used as declaration", type);
-      declarator = make_anon_name ();
+      return error_mark_node;
     }
 
-  /* `void' at top level (not within pointer)
-     is allowed only in typedefs or type names.
-     We don't complain about parms either, but that is because
-     a better error message can be made later.  */
-
-  if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
+  /* Only functions may be declared using an operator-function-id.  */
+  if (declarator
+      && TREE_CODE (declarator) == IDENTIFIER_NODE
+      && IDENTIFIER_OPNAME_P (declarator)
+      && TREE_CODE (type) != FUNCTION_TYPE
+      && TREE_CODE (type) != METHOD_TYPE)
     {
-      if (! declarator)
-       error ("unnamed variable or field declared void");
-      else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
-       {
-         if (IDENTIFIER_OPNAME_P (declarator))
-           abort ();
-         else
-           error ("variable or field `%s' declared void", name);
-       }
-      else
-       error ("variable or field declared void");
-      type = integer_type_node;
+      error ("declaration of `%D' as non-function", declarator);
+      return error_mark_node;
     }
 
+  /* We don't check parameter types here because we can emit a better
+     error message later.  */
+  if (decl_context != PARM)
+    type = check_var_type (declarator, type);
+
   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
 
@@ -9848,7 +9938,14 @@ finish_enum (tree enumtype)
      underlying type in the range bmin to bmax, where bmin and bmax are,
      respectively, the smallest and largest values of the smallest bit-
      field that can store emin and emax.  */
-  TYPE_PRECISION (enumtype) = precision;
+
+  /* The middle-end currently assumes that types with TYPE_PRECISION
+     narrower than their underlying type are suitably zero or sign
+     extended to fill their mode.  g++ doesn't make these guarantees.
+     Until the middle-end can represent such paradoxical types, we
+     set the TYPE_PRECISON to the width of the underlying type.  */
+  TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
+
   set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
 
   /* [dcl.enum]
index 364ccd8..09fe5dd 100644 (file)
@@ -1203,9 +1203,15 @@ build_anon_union_vars (tree object)
 void
 finish_anon_union (tree anon_union_decl)
 {
-  tree type = TREE_TYPE (anon_union_decl);
+  tree type;
   tree main_decl;
-  bool public_p = TREE_PUBLIC (anon_union_decl);
+  bool public_p;
+
+  if (anon_union_decl == error_mark_node)
+    return;
+
+  type = TREE_TYPE (anon_union_decl);
+  public_p = TREE_PUBLIC (anon_union_decl);
 
   /* The VAR_DECL's context is the same as the TYPE's context.  */
   DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
@@ -1566,12 +1572,14 @@ maybe_emit_vtables (tree ctype)
     return false;
 
   import_export_class (ctype);
-  import_export_vtable (primary_vtbl, ctype, 1);
 
   /* See if any of the vtables are needed.  */
   for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
-    if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))
-      break;
+    {
+      import_export_vtable (vtbl, ctype, 1);
+      if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))
+       break;
+    }
   if (!vtbl)
     {
       /* If the references to this class' vtables are optimized away,
index 988c539..5b83c60 100644 (file)
@@ -359,6 +359,7 @@ dump_type (tree t, int flags)
     case BOUND_TEMPLATE_TEMPLATE_PARM:
       {
        tree args = TYPE_TI_ARGS (t);
+       dump_qualifiers (t, after);
        pp_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
        pp_template_argument_list_start (cxx_pp);
         dump_template_argument_list (args, flags);
@@ -814,9 +815,7 @@ dump_decl (tree t, int flags)
       break;
 
     case SCOPE_REF:
-      dump_decl (TREE_OPERAND (t, 0), flags & ~TFF_DECL_SPECIFIERS);
-      pp_colon_colon (cxx_pp); 
-      dump_decl (TREE_OPERAND (t, 1), flags);
+      pp_expression (cxx_pp, t);
       break;
 
     case ARRAY_REF:
@@ -1488,6 +1487,7 @@ dump_expr (tree t, int flags)
     case CEIL_DIV_EXPR:
     case FLOOR_DIV_EXPR:
     case ROUND_DIV_EXPR:
+    case RDIV_EXPR:
       dump_binary_op ("/", t, flags);
       break;
 
@@ -1735,9 +1735,7 @@ dump_expr (tree t, int flags)
       break;
 
     case SCOPE_REF:
-      dump_type (TREE_OPERAND (t, 0), flags);
-      pp_colon_colon (cxx_pp);
-      dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
+      pp_expression (cxx_pp, t);
       break;
 
     case CAST_EXPR:
@@ -2408,6 +2406,9 @@ cp_error_at (const char *msgid, ...)
   va_end (ap);
 
   va_start (ap, msgid);
+  diagnostic_set_info (&diagnostic, msgid, &ap,
+                       input_location, DK_ERROR);
+  cp_diagnostic_starter (global_dc, &diagnostic);
   diagnostic_set_info (&diagnostic, msgid, &ap,
                        location_of (here), DK_ERROR);
   report_diagnostic (&diagnostic);
index c8112d1..e61e652 100644 (file)
@@ -594,9 +594,9 @@ build_throw (tree exp)
          fn = push_throw_library_fn (fn, tmp);
        }
       else if (really_overloaded_fn (fn))
-       {\r
+       {
          error ("`%D' should never be overloaded", fn);
-         return error_mark_node;\r
+         return error_mark_node;
        }
       fn = OVL_CURRENT (fn);
       exp = build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE));
@@ -610,18 +610,18 @@ build_throw (tree exp)
       tree temp_expr, allocate_expr;
       bool elided;
 
+      /* The CLEANUP_TYPE is the internal type of a destructor.  */
+      if (!cleanup_type)
+       {
+         tmp = void_list_node;
+         tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
+         tmp = build_function_type (void_type_node, tmp);
+         cleanup_type = build_pointer_type (tmp);
+       }
+      
       fn = get_identifier ("__cxa_throw");
       if (!get_global_value_if_present (fn, &fn))
        {
-         /* The CLEANUP_TYPE is the internal type of a destructor.  */
-         if (cleanup_type == NULL_TREE)
-           {
-             tmp = void_list_node;
-             tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
-             tmp = build_function_type (void_type_node, tmp);
-             cleanup_type = build_pointer_type (tmp);
-           }
-
          /* Declare void __cxa_throw (void*, void*, void (*)(void*)).  */
          /* ??? Second argument is supposed to be "std::type_info*".  */
          tmp = void_list_node;
@@ -631,7 +631,7 @@ build_throw (tree exp)
          tmp = build_function_type (void_type_node, tmp);
          fn = push_throw_library_fn (fn, tmp);
        }
-
+      
       /* throw expression */
       /* First, decay it.  */
       exp = decay_conversion (exp);
index e6c9ee6..22dffb1 100644 (file)
@@ -167,6 +167,9 @@ lang_specific_driver (int *in_argc, const char *const **in_argv,
                }
              saw_speclang = 1;
            }
+         /* Unrecognized libraries (e.g. -lfoo) may require libstdc++.  */
+         else if (strncmp (argv[i], "-l", 2) == 0)
+           library = (library == 0) ? 1 : library;
          else if (((argv[i][2] == '\0'
                     && strchr ("bBVDUoeTuIYmLiA", argv[i][1]) != NULL)
                    || strcmp (argv[i], "-Xlinker") == 0
index c81736c..7f974bf 100644 (file)
@@ -1378,7 +1378,7 @@ build_offset_ref (tree type, tree name, bool address_p)
   if (TREE_CODE (name) == TEMPLATE_DECL)
     return name;
 
-  if (processing_template_decl || uses_template_parms (type))
+  if (dependent_type_p (type) || type_dependent_expression_p (name))
     return build_min_nt (SCOPE_REF, type, name);
 
   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
@@ -1442,6 +1442,7 @@ build_offset_ref (tree type, tree name, bool address_p)
       return error_mark_node;
     }
 
+  /* Set up BASEBINFO for member lookup.  */
   decl = maybe_dummy_object (type, &basebinfo);
 
   if (BASELINK_P (name) || DECL_P (name))
@@ -1460,6 +1461,14 @@ build_offset_ref (tree type, tree name, bool address_p)
       return error_mark_node;
     }
 
+  if (processing_template_decl)
+    {
+      if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
+       return build_min (SCOPE_REF, TREE_TYPE (member), type, orig_name);
+      else
+       return build_min (SCOPE_REF, TREE_TYPE (member), type, name);
+    }
+
   if (TREE_CODE (member) == TYPE_DECL)
     {
       TREE_USED (member) = 1;
index 760d8b3..a92f2b4 100644 (file)
@@ -59,6 +59,7 @@
 #include "toplev.h"
 #include "varray.h"
 #include "flags.h"
+#include "target.h"
 
 /* Debugging support.  */
 
@@ -1497,12 +1498,24 @@ write_type (tree type)
        case BOOLEAN_TYPE:
        case INTEGER_TYPE:  /* Includes wchar_t.  */
        case REAL_TYPE:
+       {
+         /* Handle any target-specific fundamental types.  */
+         const char *target_mangling
+           = targetm.mangle_fundamental_type (type);
+
+         if (target_mangling)
+           {
+             write_string (target_mangling);
+             return;
+           }
+
          /* If this is a typedef, TYPE may not be one of
             the standard builtin type nodes, but an alias of one.  Use
             TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
          write_builtin_type (TYPE_MAIN_VARIANT (type));
          ++is_builtin_type;
          break;
+       }
 
        case COMPLEX_TYPE:
          write_char ('C');
index a4e996f..d627e00 100644 (file)
@@ -2968,27 +2968,6 @@ set_namespace_binding (tree name, tree scope, tree val)
   timevar_pop (TV_NAME_LOOKUP);
 }
 
-/* Compute the namespace where a declaration is defined.  */
-
-static tree
-decl_namespace (tree decl)
-{
-  timevar_push (TV_NAME_LOOKUP);
-  if (TYPE_P (decl))
-    decl = TYPE_STUB_DECL (decl);
-  while (DECL_CONTEXT (decl))
-    {
-      decl = DECL_CONTEXT (decl);
-      if (TREE_CODE (decl) == NAMESPACE_DECL)
-       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
-      if (TYPE_P (decl))
-       decl = TYPE_STUB_DECL (decl);
-      my_friendly_assert (DECL_P (decl), 390);
-    }
-
-  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, global_namespace);
-}
-
 /* Set the context of a declaration to scope. Complain if we are not
    outside scope.  */
 
@@ -3057,9 +3036,9 @@ current_decl_namespace (void)
     return TREE_PURPOSE (decl_namespace_list);
 
   if (current_class_type)
-    result = decl_namespace (TYPE_STUB_DECL (current_class_type));
+    result = decl_namespace_context (current_class_type);
   else if (current_function_decl)
-    result = decl_namespace (current_function_decl);
+    result = decl_namespace_context (current_function_decl);
   else 
     result = current_namespace;
   return result;
@@ -3187,7 +3166,7 @@ void
 push_decl_namespace (tree decl)
 {
   if (TREE_CODE (decl) != NAMESPACE_DECL)
-    decl = decl_namespace (decl);
+    decl = decl_namespace_context (decl);
   decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
                                    NULL_TREE, decl_namespace_list);
 }
@@ -3231,6 +3210,9 @@ do_namespace_alias (tree alias, tree namespace)
   alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);     
   DECL_NAMESPACE_ALIAS (alias) = namespace;
   DECL_EXTERNAL (alias) = 1;
+  DECL_CONTEXT (alias) = current_scope ();
+  if (!DECL_CONTEXT (alias))
+    DECL_CONTEXT (alias) = FROB_CONTEXT (current_namespace);
   pushdecl (alias);
 }
 
@@ -3405,7 +3387,7 @@ parse_using_directive (tree namespace, tree attribs)
        {
          if (!toplevel_bindings_p ())
            error ("strong using only meaningful at namespace scope");
-         else
+         else if (namespace != error_mark_node)
            DECL_NAMESPACE_ASSOCIATIONS (namespace)
              = tree_cons (current_namespace, 0,
                           DECL_NAMESPACE_ASSOCIATIONS (namespace));
@@ -4275,7 +4257,7 @@ arg_assoc_class (struct arg_lookup *k, tree type)
     return false;
   k->classes = tree_cons (type, NULL_TREE, k->classes);
   
-  context = decl_namespace (TYPE_MAIN_DECL (type));
+  context = decl_namespace_context (type);
   if (arg_assoc_namespace (k, context))
     return true;
   
@@ -4357,7 +4339,7 @@ arg_assoc_type (struct arg_lookup *k, tree type)
       return arg_assoc_type (k, TREE_TYPE (type));
     case UNION_TYPE:
     case ENUMERAL_TYPE:
-      return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
+      return arg_assoc_namespace (k, decl_namespace_context (type));
     case METHOD_TYPE:
       /* The basetype is referenced in the first arg type, so just
         fall through.  */
index cf3517f..2c29462 100644 (file)
@@ -1483,9 +1483,9 @@ static void cp_parser_linkage_specification
 static tree cp_parser_init_declarator
   (cp_parser *, tree, tree, bool, bool, int, bool *);
 static tree cp_parser_declarator
-  (cp_parser *, cp_parser_declarator_kind, int *, bool *);
+  (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool);
 static tree cp_parser_direct_declarator
-  (cp_parser *, cp_parser_declarator_kind, int *);
+  (cp_parser *, cp_parser_declarator_kind, int *, bool);
 static enum tree_code cp_parser_ptr_operator
   (cp_parser *, tree *, tree *);
 static tree cp_parser_cv_qualifier_seq_opt
@@ -2701,7 +2701,7 @@ cp_parser_id_expression (cp_parser *parser,
                                            /*typename_keyword_p=*/false,
                                            check_dependency_p,
                                            /*type_p=*/false,
-                                           /*is_declarator=*/false)
+                                           declarator_p)
        != NULL_TREE);
   /* If there is a nested-name-specifier, then we are looking at
      the first qualified-id production.  */
@@ -3141,6 +3141,16 @@ cp_parser_nested_name_specifier_opt (cp_parser *parser,
         might destroy it.  */
       old_scope = parser->scope;
       saved_qualifying_scope = parser->qualifying_scope;
+      /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
+        look up names in "X<T>::I" in order to determine that "Y" is
+        a template.  So, if we have a typename at this point, we make
+        an effort to look through it.  */
+      if (is_declaration 
+         && !typename_keyword_p
+         && parser->scope 
+         && TREE_CODE (parser->scope) == TYPENAME_TYPE)
+       parser->scope = resolve_typename_type (parser->scope, 
+                                              /*only_current_p=*/false);
       /* Parse the qualifying entity.  */
       new_scope 
        = cp_parser_class_or_namespace_name (parser,
@@ -3741,20 +3751,36 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
            koenig_p = false;
            if (idk == CP_ID_KIND_UNQUALIFIED)
              {
+               if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
+                 {
+                   if (args)
+                     {
+                       koenig_p = true;
+                       postfix_expression
+                         = perform_koenig_lookup (postfix_expression, args);
+                     }
+                   else
+                     postfix_expression
+                       = unqualified_fn_lookup_error (postfix_expression);
+                 }
                /* We do not perform argument-dependent lookup if
                   normal lookup finds a non-function, in accordance
                   with the expected resolution of DR 218.  */
-               if (args
-                   && (is_overloaded_fn (postfix_expression)
-                       || TREE_CODE (postfix_expression) == IDENTIFIER_NODE))
+               else if (args && is_overloaded_fn (postfix_expression))
                  {
-                   koenig_p = true;
-                   postfix_expression 
-                     = perform_koenig_lookup (postfix_expression, args);
+                   tree fn = get_first_fn (postfix_expression);
+                   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
+                     fn = OVL_CURRENT (TREE_OPERAND (fn, 0));
+                   /* Only do argument dependent lookup if regular
+                      lookup does not find a set of member functions.
+                      [basic.lookup.koenig]/2a  */
+                   if (!DECL_FUNCTION_MEMBER_P (fn))
+                     {
+                       koenig_p = true;
+                       postfix_expression
+                         = perform_koenig_lookup (postfix_expression, args);
+                     }
                  }
-               else if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
-                 postfix_expression
-                   = unqualified_fn_lookup_error (postfix_expression);
              }
          
            if (TREE_CODE (postfix_expression) == COMPONENT_REF)
@@ -3820,6 +3846,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
            tree name;
            bool dependent_p;
            bool template_p;
+           bool pseudo_destructor_p;
            tree scope = NULL_TREE;
            enum cpp_ttype token_type = token->type;
 
@@ -3870,11 +3897,34 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
 
            /* Consume the `.' or `->' operator.  */
            cp_lexer_consume_token (parser->lexer);
-           /* If the SCOPE is not a scalar type, we are looking at an
-              ordinary class member access expression, rather than a
-              pseudo-destructor-name.  */
-           if (!scope || !SCALAR_TYPE_P (scope))
+           
+           /* Assume this expression is not a pseudo-destructor access.  */
+           pseudo_destructor_p = false;
+
+           /* If the SCOPE is a scalar type, then, if this is a valid program,
+              we must be looking at a pseudo-destructor-name.  */
+           if (scope && SCALAR_TYPE_P (scope))
+             {
+               tree s = NULL_TREE;
+               tree type;
+
+               cp_parser_parse_tentatively (parser);
+               /* Parse the pseudo-destructor-name.  */
+               cp_parser_pseudo_destructor_name (parser, &s, &type);
+               if (cp_parser_parse_definitely (parser))
+                 {
+                   pseudo_destructor_p = true;
+                   postfix_expression
+                     = finish_pseudo_destructor_expr (postfix_expression,
+                                                      s, TREE_TYPE (type));
+                 }
+             }
+
+           if (!pseudo_destructor_p)
              {
+               /* If the SCOPE is not a scalar type, we are looking
+                  at an ordinary class member access expression,
+                  rather than a pseudo-destructor-name.  */
                template_p = cp_parser_optional_template_keyword (parser);
                /* Parse the id-expression.  */
                name = cp_parser_id_expression (parser,
@@ -3914,19 +3964,6 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
                postfix_expression 
                  = finish_class_member_access_expr (postfix_expression, name);
              }
-           /* Otherwise, try the pseudo-destructor-name production.  */
-           else
-             {
-               tree s = NULL_TREE;
-               tree type;
-
-               /* Parse the pseudo-destructor-name.  */
-               cp_parser_pseudo_destructor_name (parser, &s, &type);
-               /* Form the call.  */
-               postfix_expression 
-                 = finish_pseudo_destructor_expr (postfix_expression,
-                                                  s, TREE_TYPE (type));
-             }
 
            /* We no longer need to look up names in the scope of the
               object on the left-hand side of the `.' or `->'
@@ -5811,7 +5848,8 @@ cp_parser_condition (cp_parser* parser)
       /* Parse the declarator.  */
       declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
                                         /*ctor_dtor_or_conv_p=*/NULL,
-                                        /*parenthesized_p=*/NULL);
+                                        /*parenthesized_p=*/NULL,
+                                        /*member_p=*/false);
       /* Parse the attributes.  */
       attributes = cp_parser_attributes_opt (parser);
       /* Parse the asm-specification.  */
@@ -8095,6 +8133,7 @@ cp_parser_template_name (cp_parser* parser,
       if (is_declaration 
          && !template_keyword_p 
          && parser->scope && TYPE_P (parser->scope)
+         && check_dependency_p
          && dependent_type_p (parser->scope)
          /* Do not do this for dtors (or ctors), since they never
             need the template keyword before their name.  */
@@ -8548,7 +8587,8 @@ cp_parser_explicit_instantiation (cp_parser* parser)
       declarator 
        = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
                                /*ctor_dtor_or_conv_p=*/NULL,
-                               /*parenthesized_p=*/NULL);
+                               /*parenthesized_p=*/NULL,
+                               /*member_p=*/false);
       cp_parser_check_for_definition_in_return_type (declarator, 
                                                     declares_class_or_enum);
       if (declarator != error_mark_node)
@@ -8871,6 +8911,7 @@ cp_parser_simple_type_specifier (cp_parser* parser, cp_parser_flags flags,
   if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES)) 
     {
       bool qualified_p;
+      bool global_p;
 
       /* Don't gobble tokens or issue error messages if this is an
         optional type-specifier.  */
@@ -8878,8 +8919,10 @@ cp_parser_simple_type_specifier (cp_parser* parser, cp_parser_flags flags,
        cp_parser_parse_tentatively (parser);
 
       /* Look for the optional `::' operator.  */
-      cp_parser_global_scope_opt (parser,
-                                 /*current_scope_valid_p=*/false);
+      global_p
+       = (cp_parser_global_scope_opt (parser,
+                                      /*current_scope_valid_p=*/false)
+          != NULL_TREE);
       /* Look for the nested-name specifier.  */
       qualified_p
        = (cp_parser_nested_name_specifier_opt (parser,
@@ -8911,6 +8954,7 @@ cp_parser_simple_type_specifier (cp_parser* parser, cp_parser_flags flags,
        type = cp_parser_type_name (parser);
       /* Keep track of all name-lookups performed in class scopes.  */
       if (type  
+         && !global_p
          && !qualified_p
          && TREE_CODE (type) == TYPE_DECL 
          && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
@@ -9761,25 +9805,18 @@ cp_parser_asm_definition (cp_parser* parser)
       /* If the next token is `::', there are no outputs, and the
         next token is the beginning of the inputs.  */
       else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
-       {
-         /* Consume the `::' token.  */
-         cp_lexer_consume_token (parser->lexer);
-         /* The inputs are coming next.  */
-         inputs_p = true;
-       }
+       /* The inputs are coming next.  */
+       inputs_p = true;
 
       /* Look for inputs.  */
       if (inputs_p
          || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
        {
-         if (!inputs_p)
-           /* Consume the `:'.  */
-           cp_lexer_consume_token (parser->lexer);
+         /* Consume the `:' or `::'.  */
+         cp_lexer_consume_token (parser->lexer);
          /* Parse the output-operands.  */
          if (cp_lexer_next_token_is_not (parser->lexer, 
                                          CPP_COLON)
-             && cp_lexer_next_token_is_not (parser->lexer,
-                                            CPP_SCOPE)
              && cp_lexer_next_token_is_not (parser->lexer,
                                             CPP_CLOSE_PAREN))
            inputs = cp_parser_asm_operand_list (parser);
@@ -9792,9 +9829,8 @@ cp_parser_asm_definition (cp_parser* parser)
       if (clobbers_p 
          || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
        {
-         if (!clobbers_p)
-           /* Consume the `:'.  */
-           cp_lexer_consume_token (parser->lexer);
+         /* Consume the `:' or `::'.  */
+         cp_lexer_consume_token (parser->lexer);
          /* Parse the clobbers.  */
          if (cp_lexer_next_token_is_not (parser->lexer,
                                          CPP_CLOSE_PAREN))
@@ -9895,7 +9931,8 @@ cp_parser_init_declarator (cp_parser* parser,
   declarator 
     = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
                            &ctor_dtor_or_conv_p,
-                           /*parenthesized_p=*/NULL);
+                           /*parenthesized_p=*/NULL,
+                           /*member_p=*/false);
   /* Gather up the deferred checks.  */
   stop_deferring_access_checks ();
 
@@ -10178,13 +10215,16 @@ cp_parser_init_declarator (cp_parser* parser,
    expression, not a declaration.)  
  
    If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
-   the declarator is a direct-declarator of the form "(...)".  */
+   the declarator is a direct-declarator of the form "(...)".
+
+   MEMBER_P is true iff this declarator is a member-declarator.  */
 
 static tree
 cp_parser_declarator (cp_parser* parser, 
                       cp_parser_declarator_kind dcl_kind, 
                       int* ctor_dtor_or_conv_p,
-                     bool* parenthesized_p)
+                     bool* parenthesized_p,
+                     bool member_p)
 {
   cp_token *token;
   tree declarator;
@@ -10225,7 +10265,8 @@ cp_parser_declarator (cp_parser* parser,
       /* Parse the dependent declarator.  */
       declarator = cp_parser_declarator (parser, dcl_kind,
                                         /*ctor_dtor_or_conv_p=*/NULL,
-                                        /*parenthesized_p=*/NULL);
+                                        /*parenthesized_p=*/NULL,
+                                        /*member_p=*/false);
 
       /* If we are parsing an abstract-declarator, we must handle the
         case where the dependent declarator is absent.  */
@@ -10251,7 +10292,8 @@ cp_parser_declarator (cp_parser* parser,
        *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
                                                   CPP_OPEN_PAREN);
       declarator = cp_parser_direct_declarator (parser, dcl_kind,
-                                               ctor_dtor_or_conv_p);
+                                               ctor_dtor_or_conv_p,
+                                               member_p);
     }
 
   if (attributes && declarator != error_mark_node)
@@ -10299,7 +10341,8 @@ cp_parser_declarator (cp_parser* parser,
 static tree
 cp_parser_direct_declarator (cp_parser* parser,
                              cp_parser_declarator_kind dcl_kind,
-                             int* ctor_dtor_or_conv_p)
+                             int* ctor_dtor_or_conv_p,
+                            bool member_p)
 {
   cp_token *token;
   tree declarator = NULL_TREE;
@@ -10358,7 +10401,14 @@ cp_parser_direct_declarator (cp_parser* parser,
              tree params;
              unsigned saved_num_template_parameter_lists;
              
-             cp_parser_parse_tentatively (parser);
+             /* In a member-declarator, the only valid interpretation
+                of a parenthesis is the start of a
+                parameter-declaration-clause.  (It is invalid to
+                initialize a static data member with a parenthesized
+                initializer; only the "=" form of initialization is
+                permitted.)  */
+             if (!member_p)
+               cp_parser_parse_tentatively (parser);
 
              /* Consume the `('.  */
              cp_lexer_consume_token (parser->lexer);
@@ -10384,7 +10434,7 @@ cp_parser_direct_declarator (cp_parser* parser,
 
              /* If all went well, parse the cv-qualifier-seq and the
                 exception-specification.  */
-             if (cp_parser_parse_definitely (parser))
+             if (member_p || cp_parser_parse_definitely (parser))
                {
                  tree cv_qualifiers;
                  tree exception_specification;
@@ -10432,7 +10482,8 @@ cp_parser_direct_declarator (cp_parser* parser,
              parser->in_type_id_in_expr_p = true;
              declarator 
                = cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p,
-                                       /*parenthesized_p=*/NULL);
+                                       /*parenthesized_p=*/NULL,
+                                       member_p);
              parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
              first = false;
              /* Expect a `)'.  */
@@ -10850,7 +10901,8 @@ cp_parser_type_id (cp_parser* parser)
   /* Look for the declarator.  */
   abstract_declarator 
     = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,
-                           /*parenthesized_p=*/NULL);
+                           /*parenthesized_p=*/NULL,
+                           /*member_p=*/false);
   /* Check to see if there really was a declarator.  */
   if (!cp_parser_parse_definitely (parser))
     abstract_declarator = NULL_TREE;
@@ -11208,7 +11260,8 @@ cp_parser_parameter_declaration (cp_parser *parser,
       declarator = cp_parser_declarator (parser,
                                         CP_PARSER_DECLARATOR_EITHER,
                                         /*ctor_dtor_or_conv_p=*/NULL,
-                                        parenthesized_p);
+                                        parenthesized_p,
+                                        /*member_p=*/false);
       parser->default_arg_ok_p = saved_default_arg_ok_p;
       /* After the declarator, allow more attributes.  */
       attributes = chainon (attributes, cp_parser_attributes_opt (parser));
@@ -11467,18 +11520,49 @@ cp_parser_initializer (cp_parser* parser, bool* is_parenthesized_init,
 static tree
 cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
 {
-  tree initializer;
+  tree initializer = NULL_TREE;
 
   /* If it is not a `{', then we are looking at an
      assignment-expression.  */
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
     {
-      initializer 
-       = cp_parser_constant_expression (parser,
-                                       /*allow_non_constant_p=*/true,
-                                       non_constant_p);
-      if (!*non_constant_p)
-       initializer = fold_non_dependent_expr (initializer);
+      /* Speed up common initializers (simply a literal).  */
+      cp_token* token = cp_lexer_peek_token (parser->lexer);
+      cp_token* token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
+
+      if (token2->type == CPP_COMMA)
+       switch (token->type)
+         {
+         case CPP_CHAR:
+         case CPP_WCHAR:
+         case CPP_NUMBER:
+           token = cp_lexer_consume_token (parser->lexer);
+           initializer = token->value;
+           break;
+
+         case CPP_STRING:
+         case CPP_WSTRING:
+           token = cp_lexer_consume_token (parser->lexer);
+           if (TREE_CHAIN (token->value))
+             initializer = TREE_CHAIN (token->value);
+           else
+             initializer = token->value;
+           break;
+
+         default:
+           break;
+         }
+
+      /* Otherwise, fall back to the generic assignment expression.  */
+      if (!initializer)
+       {
+         initializer
+           = cp_parser_constant_expression (parser,
+                                           /*allow_non_constant_p=*/true,
+                                           non_constant_p);
+         if (!*non_constant_p)
+           initializer = fold_non_dependent_expr (initializer);
+       }
     }
   else
     {
@@ -11738,6 +11822,7 @@ cp_parser_class_specifier (cp_parser* parser)
   bool nested_name_specifier_p;
   unsigned saved_num_template_parameter_lists;
   bool pop_p = false;
+  tree scope = NULL_TREE;
 
   push_deferring_access_checks (dk_no_deferred);
 
@@ -11773,7 +11858,10 @@ cp_parser_class_specifier (cp_parser* parser)
 
   /* Start the class.  */
   if (nested_name_specifier_p)
-    pop_p = push_scope (CP_DECL_CONTEXT (TYPE_MAIN_DECL (type)));
+    {
+      scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
+      pop_p = push_scope (scope);
+    }
   type = begin_class_definition (type);
   if (type == error_mark_node)
     /* If the type is erroneous, skip the entire body of the class.  */
@@ -11796,7 +11884,7 @@ cp_parser_class_specifier (cp_parser* parser)
   if (type != error_mark_node)
     type = finish_struct (type, attributes);
   if (pop_p)
-    pop_scope (CP_DECL_CONTEXT (TYPE_MAIN_DECL (type)));
+    pop_scope (scope);
   /* If this class is not itself within the scope of another class,
      then we need to parse the bodies of all of the queued function
      definitions.  Note that the queued functions defined in a class
@@ -12524,7 +12612,8 @@ cp_parser_member_declaration (cp_parser* parser)
              declarator 
                = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
                                        &ctor_dtor_or_conv_p,
-                                       /*parenthesized_p=*/NULL);
+                                       /*parenthesized_p=*/NULL,
+                                       /*member_p=*/true);
 
              /* If something went wrong parsing the declarator, make sure
                 that we at least consume some tokens.  */
@@ -13140,7 +13229,8 @@ cp_parser_exception_declaration (cp_parser* parser)
   else
     declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
                                       /*ctor_dtor_or_conv_p=*/NULL,
-                                      /*parenthesized_p=*/NULL);
+                                      /*parenthesized_p=*/NULL,
+                                      /*member_p=*/false);
 
   /* Restore the saved message.  */
   parser->type_definition_forbidden_message = saved_message;
@@ -14994,9 +15084,7 @@ cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
 }
 
 /* Returns TRUE iff the next token is the "," or ">" ending a
-   template-argument. ">>" is also accepted (after the full
-   argument was parsed) because it's probably a typo for "> >",
-   and there is a specific diagnostic for this.  */
+   template-argument.   */
 
 static bool
 cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
@@ -15004,8 +15092,7 @@ cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
   cp_token *token;
 
   token = cp_lexer_peek_token (parser->lexer);
-  return (token->type == CPP_COMMA || token->type == CPP_GREATER 
-         || token->type == CPP_RSHIFT);
+  return (token->type == CPP_COMMA || token->type == CPP_GREATER);
 }
 
 /* Returns TRUE iff the n-th token is a ">", or the n-th is a "[" and the
index 57c89ff..6626871 100644 (file)
@@ -706,6 +706,36 @@ end_explicit_instantiation (void)
   processing_explicit_instantiation = false;
 }
 
+/* A explicit specialization or partial specialization TMPL is being
+   declared.  Check that the namespace in which the specialization is
+   occurring is permissible.  Returns false iff it is invalid to
+   specialize TMPL in the current namespace.  */
+   
+static bool
+check_specialization_namespace (tree tmpl)
+{
+  tree tpl_ns = decl_namespace_context (tmpl);
+
+  /* [tmpl.expl.spec]
+     
+     An explicit specialization shall be declared in the namespace of
+     which the template is a member, or, for member templates, in the
+     namespace of which the enclosing class or enclosing class
+     template is a member.  An explicit specialization of a member
+     function, member class or static data member of a class template
+     shall be declared in the namespace of which the class template is
+     a member.  */
+  if (is_associated_namespace (current_namespace, tpl_ns))
+    /* Same or super-using namespace.  */
+    return true;
+  else
+    {
+      pedwarn ("specialization of `%D' in different namespace", tmpl);
+      cp_pedwarn_at ("  from definition of `%#D'", tmpl);
+      return false;
+    }
+}
+
 /* The TYPE is being declared.  If it is a template type, that means it
    is a partial specialization.  Do appropriate error-checking.  */
 
@@ -731,15 +761,7 @@ maybe_process_partial_specialization (tree type)
       if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
          && !COMPLETE_TYPE_P (type))
        {
-         tree tpl_ns = decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type));
-         if (is_associated_namespace (current_namespace, tpl_ns))
-           /* Same or super-using namespace.  */;
-         else
-           {
-             pedwarn ("specializing `%#T' in different namespace", type);
-             cp_pedwarn_at ("  from definition of `%#D'",
-                            CLASSTYPE_TI_TEMPLATE (type));
-           }
+         check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
          SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
          if (processing_template_decl)
            push_template_decl (TYPE_MAIN_DECL (type));
@@ -1114,6 +1136,12 @@ register_specialization (tree spec, tree tmpl, tree args)
        }
       }
 
+  /* A specialization must be declared in the same namespace as the
+     template it is specializing.  */
+  if (DECL_TEMPLATE_SPECIALIZATION (spec)
+      && !check_specialization_namespace (tmpl))
+    DECL_CONTEXT (spec) = decl_namespace_context (tmpl);
+
   DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
      = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
 
@@ -2815,19 +2843,35 @@ push_template_decl_real (tree decl, int is_friend)
       else if (TREE_CODE (decl) == TYPE_DECL 
               && ANON_AGGRNAME_P (DECL_NAME (decl))) 
        error ("template class without a name");
-      else if (TREE_CODE (decl) == FUNCTION_DECL
-              && DECL_DESTRUCTOR_P (decl))
+      else if (TREE_CODE (decl) == FUNCTION_DECL)
        {
-         /* [temp.mem]
-            
-             A destructor shall not be a member template.  */
-         error ("destructor `%D' declared as member template", decl);
-         return error_mark_node;
+         if (DECL_DESTRUCTOR_P (decl))
+           {
+             /* [temp.mem]
+                
+                A destructor shall not be a member template.  */
+             error ("destructor `%D' declared as member template", decl);
+             return error_mark_node;
+           }
+         if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
+             && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
+                 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
+                 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
+                 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
+                     == void_list_node)))
+           {
+             /* [basic.stc.dynamic.allocation] 
+
+                An allocation function can be a function
+                template. ... Template allocation functions shall
+                have two or more parameters.  */
+             error ("invalid template declaration of `%D'", decl);
+             return decl;
+           }
        }
       else if ((DECL_IMPLICIT_TYPEDEF_P (decl)
                && CLASS_TYPE_P (TREE_TYPE (decl)))
-              || (TREE_CODE (decl) == VAR_DECL && ctx && CLASS_TYPE_P (ctx))
-              || TREE_CODE (decl) == FUNCTION_DECL)
+              || (TREE_CODE (decl) == VAR_DECL && ctx && CLASS_TYPE_P (ctx)))
        /* OK */;
       else
        {
@@ -3199,9 +3243,7 @@ convert_nontype_argument (tree type, tree expr)
           will not return the initializer.  Handle that special case
           here.  */
        if (expr == const_expr
-           && TREE_CODE (expr) == VAR_DECL
-           && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (expr)
-           && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (expr))
+           && DECL_INTEGRAL_CONSTANT_VAR_P (expr)
            /* DECL_INITIAL can be NULL if we are processing a
               variable initialized to an expression involving itself.
               We know it is initialized to a constant -- but not what
@@ -5470,14 +5512,28 @@ instantiate_class_template (tree type)
              tree tag = t;
              tree name = TYPE_IDENTIFIER (tag);
              tree newtag;
-
+             bool class_template_p;
+
+             class_template_p = (TREE_CODE (tag) != ENUMERAL_TYPE
+                                 && TYPE_LANG_SPECIFIC (tag)
+                                 && CLASSTYPE_IS_TEMPLATE (tag));
+             /* If the member is a class template, then -- even after
+                substituition -- there may be dependent types in the
+                template argument list for the class.  We increment
+                PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
+                that function will assume that no types are dependent
+                when outside of a template.  */
+             if (class_template_p)
+               ++processing_template_decl;
              newtag = tsubst (tag, args, tf_error, NULL_TREE);
+             if (class_template_p)
+               --processing_template_decl;
              if (newtag == error_mark_node)
                continue;
 
              if (TREE_CODE (newtag) != ENUMERAL_TYPE)
                {
-                 if (TYPE_LANG_SPECIFIC (tag) && CLASSTYPE_IS_TEMPLATE (tag))
+                 if (class_template_p)
                    /* Unfortunately, lookup_template_class sets
                       CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
                       instantiation (i.e., for the type of a member
@@ -5872,6 +5928,9 @@ tsubst_aggr_type (tree t,
 tree
 tsubst_default_argument (tree fn, tree type, tree arg)
 {
+  tree saved_class_ptr = NULL_TREE;
+  tree saved_class_ref = NULL_TREE;
+
   /* This default argument came from a template.  Instantiate the
      default argument here, not in tsubst.  In the case of
      something like: 
@@ -5889,12 +5948,27 @@ tsubst_default_argument (tree fn, tree type, tree arg)
      within the scope of FN.  Since push_access_scope sets
      current_function_decl, we must explicitly clear it here.  */
   current_function_decl = NULL_TREE;
+  /* The "this" pointer is not valid in a default argument.  */
+  if (cfun)
+    {
+      saved_class_ptr = current_class_ptr;
+      cp_function_chain->x_current_class_ptr = NULL_TREE;
+      saved_class_ref = current_class_ref;
+      cp_function_chain->x_current_class_ref = NULL_TREE;
+    }
 
   push_deferring_access_checks(dk_no_deferred);
   arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
                     tf_error | tf_warning, NULL_TREE);
   pop_deferring_access_checks();
 
+  /* Restore the "this" pointer.  */
+  if (cfun)
+    {
+      cp_function_chain->x_current_class_ptr = saved_class_ptr;
+      cp_function_chain->x_current_class_ref = saved_class_ref;
+    }
+
   pop_access_scope (fn);
 
   /* Make sure the default argument is reasonable.  */
@@ -6384,6 +6458,7 @@ tsubst_decl (tree t, tree args, tree type, tsubst_flags_t complain)
            type = complete_type (type);
            DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
              = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
+           type = check_var_type (DECL_NAME (r), type);
          }
        else if (DECL_SELF_REFERENCE_P (t))
          SET_DECL_SELF_REFERENCE_P (r);
@@ -6424,9 +6499,6 @@ tsubst_decl (tree t, tree args, tree type, tsubst_flags_t complain)
          register_local_specialization (r, t);
 
        TREE_CHAIN (r) = NULL_TREE;
-       if (TREE_CODE (r) == VAR_DECL && VOID_TYPE_P (type))
-         cp_error_at ("instantiation of `%D' as type `%T'", r, type);
-       /* Compute the size, alignment, etc. of R.  */
        layout_decl (r, 0);
       }
       break;
@@ -6618,6 +6690,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
       || t == integer_type_node
       || t == void_type_node
       || t == char_type_node
+      || t == unknown_type_node
       || TREE_CODE (t) == NAMESPACE_DECL)
     return t;
 
@@ -8506,6 +8579,21 @@ tsubst_copy_and_build (tree t,
                return error_mark_node;
              }
          }
+       else if (TREE_CODE (member) == SCOPE_REF
+                && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
+                && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
+         {
+           if (complain & tf_error)
+             {
+               if (TYPE_P (TREE_OPERAND (member, 0)))
+                 error ("`%T' is not a class or namespace", 
+                        TREE_OPERAND (member, 0));
+               else
+                 error ("`%D' is not a class or namespace", 
+                        TREE_OPERAND (member, 0));
+             }
+           return error_mark_node;
+         }
        else if (TREE_CODE (member) == FIELD_DECL)
          return finish_non_static_data_member (member, object, NULL_TREE);
 
@@ -8574,6 +8662,14 @@ tsubst_copy_and_build (tree t,
                             tsubst_copy (TREE_TYPE (t), args, complain, 
                                          in_decl));
 
+    case CONST_DECL:
+      t = tsubst_copy (t, args, complain, in_decl);
+      /* As in finish_id_expression, we resolve enumeration constants
+        to their underlying values.  */
+      if (TREE_CODE (t) == CONST_DECL)
+       return DECL_INITIAL (t);
+      return t;
+
     default:
       return tsubst_copy (t, args, complain, in_decl);
     }
@@ -9540,7 +9636,7 @@ template_decl_level (tree decl)
 
 /* Decide whether ARG can be unified with PARM, considering only the
    cv-qualifiers of each type, given STRICT as documented for unify.
-   Returns nonzero iff the unification is OK on that basis.*/
+   Returns nonzero iff the unification is OK on that basis. */
 
 static int
 check_cv_quals_for_unify (int strict, tree arg, tree parm)
@@ -9548,17 +9644,26 @@ check_cv_quals_for_unify (int strict, tree arg, tree parm)
   int arg_quals = cp_type_quals (arg);
   int parm_quals = cp_type_quals (parm);
 
-  if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM)
-    {
-      /* If the cvr quals of parm will not unify with ARG, they'll be
-        ignored in instantiation, so we have to do the same here.  */
-      if (TREE_CODE (arg) == REFERENCE_TYPE)
-       parm_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
-      if (!POINTER_TYPE_P (arg) &&
-         TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
-       parm_quals &= ~TYPE_QUAL_RESTRICT;
+  if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
+      && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
+    {
+      /*  Although a CVR qualifier is ignored when being applied to a
+          substituted template parameter ([8.3.2]/1 for example), that
+          does not apply during deduction [14.8.2.4]/1, (even though
+          that is not explicitly mentioned, [14.8.2.4]/9 indicates
+          this).  Except when we're allowing additional CV qualifiers
+          at the outer level [14.8.2.1]/3,1st bullet.  */
+      if ((TREE_CODE (arg) == REFERENCE_TYPE
+          || TREE_CODE (arg) == FUNCTION_TYPE
+          || TREE_CODE (arg) == METHOD_TYPE)
+         && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
+       return 0;
+
+      if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
+         && (parm_quals & TYPE_QUAL_RESTRICT))
+       return 0;
     }
-  
+
   if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
       && (arg_quals & parm_quals) != parm_quals)
     return 0;
@@ -9824,7 +9929,10 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
       else if ((strict & UNIFY_ALLOW_INTEGER)
               && (TREE_CODE (tparm) == INTEGER_TYPE
                   || TREE_CODE (tparm) == BOOLEAN_TYPE))
-       /* OK */;
+       /* Convert the ARG to the type of PARM; the deduced non-type
+          template argument must exactly match the types of the
+          corresponding parameter.  */
+       arg = fold (build_nop (TREE_TYPE (parm), arg));
       else if (uses_template_parms (tparm))
        /* We haven't deduced the type of this parameter yet.  Try again
           later.  */
@@ -9904,6 +10012,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
     case VECTOR_TYPE:
     case INTEGER_TYPE:
     case BOOLEAN_TYPE:
+    case ENUMERAL_TYPE:
     case VOID_TYPE:
       if (TREE_CODE (arg) != TREE_CODE (parm))
        return 1;
@@ -10099,10 +10208,8 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
          else
            return 0;
        }
-      else
-       sorry ("use of `%s' in template type unification",
-              tree_code_name [(int) TREE_CODE (parm)]);
-
+      sorry ("use of `%s' in template type unification",
+            tree_code_name [(int) TREE_CODE (parm)]);
       return 1;
     }
 }
@@ -11187,6 +11294,8 @@ instantiate_decl (tree d, int defer_ok)
          if (!COMPLETE_TYPE_P (DECL_CONTEXT (d)))
            pop_nested_class ();
        }
+      /* We're not deferring instantiation any more.  */
+      TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
     }
   else if (TREE_CODE (d) == FUNCTION_DECL)
     {
@@ -11239,14 +11348,14 @@ instantiate_decl (tree d, int defer_ok)
       htab_delete (local_specializations);
       local_specializations = saved_local_specializations;
 
+      /* We're not deferring instantiation any more.  */
+      TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
+
       /* Finish the function.  */
       d = finish_function (0);
       expand_or_defer_fn (d);
     }
 
-  /* We're not deferring instantiation any more.  */
-  TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
-
   if (need_push)
     pop_from_top_level ();
 
@@ -11916,6 +12025,9 @@ type_dependent_expression_p (tree expression)
          if (TREE_CODE (expression) == IDENTIFIER_NODE)
            return false;
        }
+      /* SCOPE_REF with non-null TREE_TYPE is always non-dependent.  */
+      if (TREE_CODE (expression) == SCOPE_REF)
+       return false;
       
       if (TREE_CODE (expression) == BASELINK)
        expression = BASELINK_FUNCTIONS (expression);
@@ -12020,8 +12132,9 @@ dependent_template_p (tree tmpl)
   if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
       || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
     return true;
-  /* So are qualified names that have not been looked up.  */
-  if (TREE_CODE (tmpl) == SCOPE_REF)
+  /* So arenames that have not been looked up.  */
+  if (TREE_CODE (tmpl) == SCOPE_REF
+      || TREE_CODE (tmpl) == IDENTIFIER_NODE)
     return true;
   /* So are member templates of dependent classes.  */
   if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
index 65ed660..0dfdb92 100644 (file)
@@ -78,6 +78,7 @@ struct vbase_info
   tree inits;
 };
 
+static int is_subobject_of_p (tree, tree);
 static tree dfs_check_overlap (tree, void *);
 static tree dfs_no_overlap_yet (tree, int, void *);
 static base_kind lookup_base_r (tree, tree, base_access, bool, tree *);
@@ -97,7 +98,6 @@ static struct search_level *pop_search_level (struct stack_level *);
 static tree bfs_walk (tree, tree (*) (tree, void *),
                      tree (*) (tree, int, void *), void *);
 static tree lookup_field_queue_p (tree, int, void *);
-static int shared_member_p (tree);
 static tree lookup_field_r (tree, void *);
 static tree dfs_accessible_queue_p (tree, int, void *);
 static tree dfs_accessible_p (tree, void *);
@@ -891,10 +891,26 @@ friend_accessible_p (tree scope, tree decl, tree binfo)
 
       /* Or an instantiation of something which is a friend.  */
       if (DECL_TEMPLATE_INFO (scope))
-       return friend_accessible_p (DECL_TI_TEMPLATE (scope), decl, binfo);
+       {
+         int ret;
+         /* Increment processing_template_decl to make sure that
+            dependent_type_p works correctly.  */
+         ++processing_template_decl;
+         ret = friend_accessible_p (DECL_TI_TEMPLATE (scope), decl, binfo);
+         --processing_template_decl;
+         return ret;
+       }
     }
   else if (CLASSTYPE_TEMPLATE_INFO (scope))
-    return friend_accessible_p (CLASSTYPE_TI_TEMPLATE (scope), decl, binfo);
+    {
+      int ret;
+      /* Increment processing_template_decl to make sure that
+        dependent_type_p works correctly.  */
+      ++processing_template_decl;
+      ret = friend_accessible_p (CLASSTYPE_TI_TEMPLATE (scope), decl, binfo);
+      --processing_template_decl;
+      return ret;
+    }
 
   return 0;
 }
@@ -1058,7 +1074,6 @@ template_self_reference_p (tree type, tree decl)
           && DECL_NAME (decl) == constructor_name (type));
 }
 
-
 /* Nonzero for a class member means that it is shared between all objects
    of that class.
 
@@ -1069,7 +1084,7 @@ template_self_reference_p (tree type, tree decl)
 
    This function checks that T contains no nonstatic members.  */
 
-static int
+int
 shared_member_p (tree t)
 {
   if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == TYPE_DECL \
@@ -1088,6 +1103,27 @@ shared_member_p (tree t)
   return 0;
 }
 
+/* Routine to see if the sub-object denoted by the binfo PARENT can be
+   found as a base class and sub-object of the object denoted by
+   BINFO.  */
+
+static int
+is_subobject_of_p (tree parent, tree binfo)
+{
+  tree probe;
+  
+  for (probe = parent; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
+    {
+      if (probe == binfo)
+       return 1;
+      if (TREE_VIA_VIRTUAL (probe))
+       return (purpose_member (BINFO_TYPE (probe),
+                               CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
+               != NULL_TREE);
+    }
+  return 0;
+}
+
 /* DATA is really a struct lookup_field_info.  Look for a field with
    the name indicated there in BINFO.  If this function returns a
    non-NULL value it is the result of the lookup.  Called from
@@ -1155,12 +1191,14 @@ lookup_field_r (tree binfo, void *data)
 
   /* If the lookup already found a match, and the new value doesn't
      hide the old one, we might have an ambiguity.  */
-  if (lfi->rval_binfo && !original_binfo (lfi->rval_binfo, binfo))
+  if (lfi->rval_binfo
+      && !is_subobject_of_p (lfi->rval_binfo, binfo))
+    
     {
       if (nval == lfi->rval && shared_member_p (nval))
        /* The two things are really the same.  */
        ;
-      else if (original_binfo (binfo, lfi->rval_binfo))
+      else if (is_subobject_of_p (binfo, lfi->rval_binfo))
        /* The previous value hides the new one.  */
        ;
       else
index 966b004..f41e503 100644 (file)
@@ -1388,19 +1388,16 @@ finish_qualified_id_expr (tree qualifying_class, tree expr, bool done,
                                          qualifying_class);
   else if (BASELINK_P (expr) && !processing_template_decl)
     {
-      tree fn;
       tree fns;
 
       /* See if any of the functions are non-static members.  */
       fns = BASELINK_FUNCTIONS (expr);
       if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
        fns = TREE_OPERAND (fns, 0);
-      for (fn = fns; fn; fn = OVL_NEXT (fn))
-       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
-         break;
       /* If so, the expression may be relative to the current
         class.  */
-      if (fn && current_class_type 
+      if (!shared_member_p (fns)
+         && current_class_type 
          && DERIVED_FROM_P (qualifying_class, current_class_type))
        expr = (build_class_member_access_expr 
                (maybe_dummy_object (qualifying_class, NULL),
@@ -2567,25 +2564,15 @@ finish_id_expression (tree id_expression,
       /* Only certain kinds of names are allowed in constant
        expression.  Enumerators and template parameters 
        have already been handled above.  */
-      if (integral_constant_expression_p)
+      if (integral_constant_expression_p
+         && !DECL_INTEGRAL_CONSTANT_VAR_P (decl))
        {
-           /* Const variables or static data members of integral or
-             enumeration types initialized with constant expressions
-             are OK.  */
-         if (TREE_CODE (decl) == VAR_DECL
-             && CP_TYPE_CONST_P (TREE_TYPE (decl))
-             && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl))
-             && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
-           ;
-         else
+         if (!allow_non_integral_constant_expression_p)
            {
-             if (!allow_non_integral_constant_expression_p)
-               {
-                 error ("`%D' cannot appear in a constant-expression", decl);
-                 return error_mark_node;
-               }
-             *non_integral_constant_expression_p = true;
+             error ("`%D' cannot appear in a constant-expression", decl);
+             return error_mark_node;
            }
+         *non_integral_constant_expression_p = true;
        }
       
       if (TREE_CODE (decl) == NAMESPACE_DECL)
@@ -2643,7 +2630,8 @@ finish_id_expression (tree id_expression,
            mark_used (first_fn);
 
          if (TREE_CODE (first_fn) == FUNCTION_DECL
-             && DECL_FUNCTION_MEMBER_P (first_fn))
+             && DECL_FUNCTION_MEMBER_P (first_fn)
+             && !shared_member_p (decl))
            {
              /* A set of member functions.  */
              decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
@@ -2935,18 +2923,6 @@ expand_body (tree fn)
 
   extract_interface_info ();
 
-  /* If this function is marked with the constructor attribute, add it
-     to the list of functions to be called along with constructors
-     from static duration objects.  */
-  if (DECL_STATIC_CONSTRUCTOR (fn))
-    static_ctors = tree_cons (NULL_TREE, fn, static_ctors);
-
-  /* If this function is marked with the destructor attribute, add it
-     to the list of functions to be called along with destructors from
-     static duration objects.  */
-  if (DECL_STATIC_DESTRUCTOR (fn))
-    static_dtors = tree_cons (NULL_TREE, fn, static_dtors);
-
   if (DECL_CLONED_FUNCTION_P (fn))
     {
       /* If this is a clone, go through the other clones now and mark
@@ -3009,6 +2985,18 @@ expand_or_defer_fn (tree fn)
   if (DECL_DECLARED_INLINE_P (fn))
     import_export_decl (fn);
 
+  /* If this function is marked with the constructor attribute, add it
+     to the list of functions to be called along with constructors
+     from static duration objects.  */
+  if (DECL_STATIC_CONSTRUCTOR (fn))
+    static_ctors = tree_cons (NULL_TREE, fn, static_ctors);
+
+  /* If this function is marked with the destructor attribute, add it
+     to the list of functions to be called along with destructors from
+     static duration objects.  */
+  if (DECL_STATIC_DESTRUCTOR (fn))
+    static_dtors = tree_cons (NULL_TREE, fn, static_dtors);
+
   function_depth++;
 
   /* Expand or defer, at the whim of the compilation unit manager.  */
@@ -3035,6 +3023,27 @@ nullify_returns_r (tree* tp, int* walk_subtrees, void* data)
   else if (TREE_CODE (*tp) == CLEANUP_STMT
           && CLEANUP_DECL (*tp) == nrv)
     CLEANUP_EH_ONLY (*tp) = 1;
+  /* Replace the DECL_STMT for the NRV with an initialization of the
+     RESULT_DECL, if needed.  */
+  else if (TREE_CODE (*tp) == DECL_STMT
+          && DECL_STMT_DECL (*tp) == nrv)
+    {
+      tree init;
+      if (DECL_INITIAL (nrv)
+         && DECL_INITIAL (nrv) != error_mark_node)
+       {
+         init = build (INIT_EXPR, void_type_node,
+                       DECL_RESULT (current_function_decl),
+                       DECL_INITIAL (nrv));
+         DECL_INITIAL (nrv) = error_mark_node;
+       }
+      else
+       init = NULL_TREE;
+      init = build_stmt (EXPR_STMT, init);
+      TREE_CHAIN (init) = TREE_CHAIN (*tp);
+      STMT_LINENO (init) = STMT_LINENO (*tp);
+      *tp = init;
+    }
 
   /* Keep iterating.  */
   return NULL_TREE;
index 4636e9a..351467c 100644 (file)
@@ -431,11 +431,6 @@ cp_build_qualified_type_real (tree type,
 {
   tree result;
   int bad_quals = TYPE_UNQUALIFIED;
-  /* We keep bad function qualifiers separate, so that we can decide
-     whether to implement DR 295 or not. DR 295 break existing code,
-     unfortunately. Remove this variable to implement the defect
-     report.  */
-  int bad_func_quals = TYPE_UNQUALIFIED;
 
   if (type == error_mark_node)
     return type;
@@ -505,8 +500,6 @@ cp_build_qualified_type_real (tree type,
          || TREE_CODE (type) == METHOD_TYPE))
     {
       bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
-      if (TREE_CODE (type) != REFERENCE_TYPE)
-       bad_func_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
       type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
     }
   
@@ -525,21 +518,17 @@ cp_build_qualified_type_real (tree type,
     /*OK*/;
   else if (!(complain & (tf_error | tf_ignore_bad_quals)))
     return error_mark_node;
-  else if (bad_func_quals && !(complain & tf_error))
-    return error_mark_node;
   else
     {
       if (complain & tf_ignore_bad_quals)
        /* We're not going to warn about constifying things that can't
           be constified.  */
        bad_quals &= ~TYPE_QUAL_CONST;
-      bad_quals |= bad_func_quals;
       if (bad_quals)
        {
          tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
  
-         if (!(complain & tf_ignore_bad_quals)
-             || bad_func_quals)
+         if (!(complain & tf_ignore_bad_quals))
            error ("`%V' qualifiers cannot be applied to `%T'",
                   bad_type, type);
        }
@@ -1557,6 +1546,12 @@ cp_tree_equal (tree t1, tree t2)
     case IDENTIFIER_NODE:
       return false;
 
+    case BASELINK:
+      return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
+             && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
+             && cp_tree_equal (BASELINK_FUNCTIONS (t1),
+                               BASELINK_FUNCTIONS (t2)));
+
     case TEMPLATE_PARM_INDEX:
       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
              && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
@@ -1775,6 +1770,8 @@ pod_type_p (tree t)
     return 1; /* pointer to non-member */
   if (TYPE_PTR_TO_MEMBER_P (t))
     return 1; /* pointer to member */
+  if (TREE_CODE (t) == VECTOR_TYPE)
+    return 1; /* vectors are (small) arrays of scalars */
   
   if (! CLASS_TYPE_P (t))
     return 0; /* other non-class type (reference or function) */
@@ -2505,6 +2502,8 @@ stabilize_init (tree init, tree *initp)
        t = TREE_OPERAND (t, 1);
       if (TREE_CODE (t) == TARGET_EXPR)
        t = TARGET_EXPR_INITIAL (t);
+      if (TREE_CODE (t) == COMPOUND_EXPR)
+       t = expr_last (t);
       if (TREE_CODE (t) == CONSTRUCTOR
          && CONSTRUCTOR_ELTS (t) == NULL_TREE)
        {
index 5044db4..d7c1cb3 100644 (file)
@@ -3548,6 +3548,24 @@ build_x_unary_op (enum tree_code code, tree xarg)
     {
       if (type_dependent_expression_p (xarg))
        return build_min_nt (code, xarg, NULL_TREE);
+
+      /* For non-dependent pointer-to-member, the SCOPE_REF will be
+        processed during template substitution.  Just compute the
+        right type here and build an ADDR_EXPR around it for
+        diagnostics.  */
+      if (code == ADDR_EXPR && TREE_CODE (xarg) == SCOPE_REF)
+       {
+         tree type;
+         if (TREE_TYPE (xarg) == unknown_type_node)
+           type = unknown_type_node;
+         else if (TREE_CODE (TREE_TYPE (xarg)) == FUNCTION_TYPE)
+           type = build_pointer_type (TREE_TYPE (xarg));
+         else
+           type = build_ptrmem_type (TREE_OPERAND (xarg, 0),
+                                     TREE_TYPE (xarg));
+         return build_min (code, type, xarg, NULL_TREE);
+       }
+
       xarg = build_non_dependent_expr (xarg);
     }
 
@@ -5509,7 +5527,10 @@ build_ptrmemfunc (tree type, tree pfn, int force)
        }
 
       /* Just adjust the DELTA field.  */
-      my_friendly_assert (TREE_TYPE (delta) == ptrdiff_type_node, 20030727);
+      my_friendly_assert 
+       (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (delta),
+                                                   ptrdiff_type_node), 
+        20030727);
       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
        n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
       delta = cp_build_binary_op (PLUS_EXPR, delta, n);
index 300e8e6..f11dbe1 100644 (file)
@@ -445,28 +445,18 @@ store_init_value (tree decl, tree init)
        init = build_x_compound_expr_from_list (init, "initializer");
     }
 
-  /* End of special C++ code.  */
-
   /* Digest the specified initializer into an expression.  */
   value = digest_init (type, init, (tree *) 0);
-
-  /* Store the expression if valid; else report error.  */
-
-  if (TREE_CODE (value) == ERROR_MARK)
-    ;
-  /* Other code expects that initializers for objects of types that need
-     constructing never make it into DECL_INITIAL, and passes 'init' to
-     build_aggr_init without checking DECL_INITIAL.  So just return.  */
-  else if (TYPE_NEEDS_CONSTRUCTING (type))
-    return build (INIT_EXPR, type, decl, value);
-  else if (TREE_STATIC (decl)
-          && (! TREE_CONSTANT (value)
-              || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
+  /* If the initializer is not a constant, fill in DECL_INITIAL with
+     the bits that are constant, and then return an expression that
+     will perform the dynamic initialization.  */
+  if (value != error_mark_node
+      && (! TREE_CONSTANT (value)
+         || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
     return split_nonconstant_init (decl, value);
-  
-  /* Store the VALUE in DECL_INITIAL.  If we're building a
-     statement-tree we will actually expand the initialization later
-     when we output this function.  */
+  /* If the value is a constant, just put it in DECL_INITIAL.  If DECL
+     is an automatic variable, the middle end will turn this into a
+     dynamic initialization later.  */
   DECL_INITIAL (decl) = value;
   return NULL_TREE;
 }
index 5603f5b..cb35b6c 100644 (file)
@@ -745,18 +745,22 @@ _cpp_parse_expr (cpp_reader *pfile)
        }
       else if (want_value)
        {
-         /* Ordering here is subtle and intended to favor the
-            missing parenthesis diagnostics over alternatives.  */
-         if (op.op == CPP_CLOSE_PAREN)
-           {
-             if (top->op == CPP_OPEN_PAREN)
-               SYNTAX_ERROR ("void expression between '(' and ')'");
-           }
-         else if (top->op == CPP_EOF)
+         /* We want a number (or expression) and haven't got one.
+            Try to emit a specific diagnostic.  */
+         if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
+           SYNTAX_ERROR ("missing expression between '(' and ')'");
+
+         if (op.op == CPP_EOF && top->op == CPP_EOF)
            SYNTAX_ERROR ("#if with no expression");
+
          if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
            SYNTAX_ERROR2 ("operator '%s' has no right operand",
                           cpp_token_as_text (pfile, top->token));
+         else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
+           /* Complain about missing paren during reduction.  */;
+         else
+           SYNTAX_ERROR2 ("operator '%s' has no left operand",
+                          cpp_token_as_text (pfile, op.token));
        }
 
       top = reduce (pfile, top, op.op);
index cf144a7..1ca793d 100644 (file)
@@ -795,7 +795,7 @@ make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
   cpp_dir *dir;
 
   hash_slot = (struct file_hash_entry **)
-    htab_find_slot_with_hash (pfile->file_hash, dir_name,
+    htab_find_slot_with_hash (pfile->dir_hash, dir_name,
                              htab_hash_string (dir_name),
                              INSERT);
 
@@ -894,6 +894,8 @@ _cpp_init_files (cpp_reader *pfile)
 {
   pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
                                        NULL, xcalloc, free);
+  pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
+                                       NULL, xcalloc, free);
   allocate_file_hash_entries (pfile);
 }
 
@@ -902,6 +904,7 @@ void
 _cpp_cleanup_files (cpp_reader *pfile)
 {
   htab_delete (pfile->file_hash);
+  htab_delete (pfile->dir_hash);
 }
 
 /* Enter a file name in the hash for the sake of cpp_included.  */
index 3b0d901..e30cdca 100644 (file)
@@ -362,6 +362,7 @@ struct cpp_reader
 
   /* File and directory hash table.  */
   struct htab *file_hash;
+  struct htab *dir_hash;
   struct file_hash_entry *file_hash_entries;
   unsigned int file_hash_entries_allocated, file_hash_entries_used;
 
index 0776476..ae30568 100644 (file)
@@ -618,6 +618,8 @@ post_options (cpp_reader *pfile)
 
   if (CPP_OPTION (pfile, traditional))
     {
+      CPP_OPTION (pfile, cplusplus_comments) = 0;
+
       /* Traditional CPP does not accurately track column information.  */
       CPP_OPTION (pfile, show_column) = 0;
       CPP_OPTION (pfile, trigraphs) = 0;
index b9a29a0..580ee3c 100644 (file)
@@ -445,9 +445,18 @@ STATIC func_ptr __DTOR_END__[1]
 #ifdef EH_FRAME_SECTION_NAME
 /* Terminate the frame unwind info section with a 4byte 0 as a sentinel;
    this would be the 'length' field in a real FDE.  */
-STATIC EH_FRAME_SECTION_CONST int __FRAME_END__[]
-     __attribute__ ((unused, mode(SI), section(EH_FRAME_SECTION_NAME),
-                    aligned(4)))
+# if __INT_MAX__ == 2147483647
+typedef int int32;
+# elif __LONG_MAX__ == 2147483647
+typedef long int32;
+# elif __SHRT_MAX__ == 2147483647
+typedef short int32;
+# else
+#  error "Missing a 4 byte integer"
+# endif
+STATIC EH_FRAME_SECTION_CONST int32 __FRAME_END__[]
+     __attribute__ ((unused, section(EH_FRAME_SECTION_NAME),
+                    aligned(sizeof(int32))))
      = { 0 };
 #endif /* EH_FRAME_SECTION_NAME */
 
index 139acac..447d972 100644 (file)
@@ -83,11 +83,12 @@ Registers and "quantity numbers":
    `reg_qty' records what quantity a register is currently thought
    of as containing.
 
-   All real quantity numbers are greater than or equal to `max_reg'.
-   If register N has not been assigned a quantity, reg_qty[N] will equal N.
+   All real quantity numbers are greater than or equal to zero.
+   If register N has not been assigned a quantity, reg_qty[N] will
+   equal -N - 1, which is always negative.
 
-   Quantity numbers below `max_reg' do not exist and none of the `qty_table'
-   entries should be referenced with an index below `max_reg'.
+   Quantity numbers below zero do not exist and none of the `qty_table'
+   entries should be referenced with a negative index.
 
    We also maintain a bidirectional chain of registers for each
    quantity number.  The `qty_table` members `first_reg' and `last_reg',
@@ -539,7 +540,7 @@ struct table_elt
 /* Determine if the quantity number for register X represents a valid index
    into the qty_table.  */
 
-#define REGNO_QTY_VALID_P(N) (REG_QTY (N) != (int) (N))
+#define REGNO_QTY_VALID_P(N) (REG_QTY (N) >= 0)
 
 static struct table_elt *table[HASH_SIZE];
 
@@ -943,7 +944,7 @@ get_cse_reg_info (unsigned int regno)
       p->reg_tick = 1;
       p->reg_in_table = -1;
       p->subreg_ticked = -1;
-      p->reg_qty = regno;
+      p->reg_qty = -regno - 1;
       p->regno = regno;
       p->next = cse_reg_info_used_list;
       cse_reg_info_used_list = p;
@@ -967,7 +968,7 @@ new_basic_block (void)
 {
   int i;
 
-  next_qty = max_reg;
+  next_qty = 0;
 
   /* Clear out hash table state for this pass.  */
 
@@ -1113,7 +1114,7 @@ delete_reg_equiv (unsigned int reg)
   int p, n;
 
   /* If invalid, do nothing.  */
-  if (q == (int) reg)
+  if (! REGNO_QTY_VALID_P (reg))
     return;
 
   ent = &qty_table[q];
@@ -1130,7 +1131,7 @@ delete_reg_equiv (unsigned int reg)
   else
     ent->first_reg = n;
 
-  REG_QTY (reg) = reg;
+  REG_QTY (reg) = -reg - 1;
 }
 
 /* Remove any invalid expressions from the hash table
@@ -1727,15 +1728,20 @@ merge_equiv_classes (struct table_elt *class1, struct table_elt *class2)
         hash code (it also isn't necessary).  */
       if (GET_CODE (exp) == REG || exp_equiv_p (exp, exp, 1, 0))
        {
+         bool need_rehash = false;
+
          hash_arg_in_memory = 0;
          hash = HASH (exp, mode);
 
          if (GET_CODE (exp) == REG)
-           delete_reg_equiv (REGNO (exp));
+           {
+             need_rehash = REGNO_QTY_VALID_P (REGNO (exp));
+             delete_reg_equiv (REGNO (exp));
+           }
 
          remove_from_table (elt, hash);
 
-         if (insert_regs (exp, class1, 0))
+         if (insert_regs (exp, class1, 0) || need_rehash)
            {
              rehash_using_reg (exp);
              hash = HASH (exp, mode);
@@ -2008,14 +2014,13 @@ rehash_using_reg (rtx x)
     return;
 
   /* Scan all hash chains looking for valid entries that mention X.
-     If we find one and it is in the wrong hash chain, move it.  We can skip
-     objects that are registers, since they are handled specially.  */
+     If we find one and it is in the wrong hash chain, move it.  */
 
   for (i = 0; i < HASH_SIZE; i++)
     for (p = table[i]; p; p = next)
       {
        next = p->next_same_hash;
-       if (GET_CODE (p->exp) != REG && reg_mentioned_p (x, p->exp)
+       if (reg_mentioned_p (x, p->exp)
            && exp_equiv_p (p->exp, p->exp, 1, 0)
            && i != (hash = safe_hash (p->exp, p->mode) & HASH_MASK))
          {
@@ -3864,6 +3869,10 @@ fold_rtx (rtx x, rtx insn)
       break;
 
     case '<':
+      /* Don't perform any simplifications of vector mode comparisons.  */
+      if (VECTOR_MODE_P (mode))
+       break;
+
       /* See what items are actually being compared and set FOLDED_ARG[01]
         to those values and CODE to the actual comparison code.  If any are
         constant, set CONST_ARG0 and CONST_ARG1 appropriately.  We needn't
@@ -7066,8 +7075,6 @@ cse_main (rtx f, int nregs, int after_loop, FILE *file)
       if (max_qty < 500)
        max_qty = 500;
 
-      max_qty += max_reg;
-
       /* If this basic block is being extended by following certain jumps,
          (see `cse_end_of_basic_block'), we reprocess the code from the start.
          Otherwise, we start after this basic block.  */
@@ -7130,11 +7137,8 @@ cse_basic_block (rtx from, rtx to, struct branch_path *next_branch,
   int num_insns = 0;
   int no_conflict = 0;
 
-  /* This array is undefined before max_reg, so only allocate
-     the space actually needed and adjust the start.  */
-
-  qty_table = xmalloc ((max_qty - max_reg) * sizeof (struct qty_table_elem));
-  qty_table -= max_reg;
+  /* Allocate the space needed by qty_table.  */
+  qty_table = xmalloc (max_qty * sizeof (struct qty_table_elem));
 
   new_basic_block ();
 
@@ -7245,7 +7249,7 @@ cse_basic_block (rtx from, rtx to, struct branch_path *next_branch,
        {
          if (to == 0)
            {
-             free (qty_table + max_reg);
+             free (qty_table);
              return 0;
            }
 
@@ -7280,7 +7284,7 @@ cse_basic_block (rtx from, rtx to, struct branch_path *next_branch,
          /* If TO was the last insn in the function, we are done.  */
          if (insn == 0)
            {
-             free (qty_table + max_reg);
+             free (qty_table);
              return 0;
            }
 
@@ -7289,7 +7293,7 @@ cse_basic_block (rtx from, rtx to, struct branch_path *next_branch,
          prev = prev_nonnote_insn (to);
          if (prev && GET_CODE (prev) == BARRIER)
            {
-             free (qty_table + max_reg);
+             free (qty_table);
              return insn;
            }
 
@@ -7340,7 +7344,7 @@ cse_basic_block (rtx from, rtx to, struct branch_path *next_branch,
       && LABEL_NUSES (JUMP_LABEL (insn)) == 1)
     cse_around_loop (JUMP_LABEL (insn));
 
-  free (qty_table + max_reg);
+  free (qty_table);
 
   return to ? NEXT_INSN (to) : 0;
 }
index 95b4cc7..9c1d936 100644 (file)
@@ -60,7 +60,6 @@ static void add_mem_for_addr (cselib_val *, cselib_val *, rtx);
 static cselib_val *cselib_lookup_mem (rtx, int);
 static void cselib_invalidate_regno (unsigned int, enum machine_mode);
 static void cselib_invalidate_mem (rtx);
-static void cselib_invalidate_rtx (rtx, rtx, void *);
 static void cselib_record_set (rtx, cselib_val *, cselib_val *);
 static void cselib_record_sets (rtx);
 
@@ -1135,13 +1134,10 @@ cselib_invalidate_mem (rtx mem_rtx)
   *vp = &dummy_val;
 }
 
-/* Invalidate DEST, which is being assigned to or clobbered.  The second and
-   the third parameter exist so that this function can be passed to
-   note_stores; they are ignored.  */
+/* Invalidate DEST, which is being assigned to or clobbered.  */
 
-static void
-cselib_invalidate_rtx (rtx dest, rtx ignore ATTRIBUTE_UNUSED,
-                      void *data ATTRIBUTE_UNUSED)
+void
+cselib_invalidate_rtx (rtx dest)
 {
   while (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == SIGN_EXTRACT
         || GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SUBREG)
@@ -1157,7 +1153,16 @@ cselib_invalidate_rtx (rtx dest, rtx ignore ATTRIBUTE_UNUSED,
      invalidate the stack pointer correctly.  Note that invalidating
      the stack pointer is different from invalidating DEST.  */
   if (push_operand (dest, GET_MODE (dest)))
-    cselib_invalidate_rtx (stack_pointer_rtx, NULL_RTX, NULL);
+    cselib_invalidate_rtx (stack_pointer_rtx);
+}
+
+/* A wrapper for cselib_invalidate_rtx to be called via note_stores.  */
+
+static void
+cselib_invalidate_rtx_note_stores (rtx dest, rtx ignore ATTRIBUTE_UNUSED,
+                                  void *data ATTRIBUTE_UNUSED)
+{
+  cselib_invalidate_rtx (dest);
 }
 
 /* Record the result of a SET instruction.  DEST is being set; the source
@@ -1290,7 +1295,7 @@ cselib_record_sets (rtx insn)
   /* Invalidate all locations written by this insn.  Note that the elts we
      looked up in the previous loop aren't affected, just some of their
      locations may go away.  */
-  note_stores (body, cselib_invalidate_rtx, NULL);
+  note_stores (body, cselib_invalidate_rtx_note_stores, NULL);
 
   /* If this is an asm, look for duplicate sets.  This can happen when the
      user uses the same value as an output multiple times.  This is valid
@@ -1334,8 +1339,6 @@ cselib_process_insn (rtx insn)
 
   if (find_reg_note (insn, REG_LIBCALL, NULL))
     cselib_current_insn_in_libcall = true;
-  if (find_reg_note (insn, REG_RETVAL, NULL))
-    cselib_current_insn_in_libcall = false;
   cselib_current_insn = insn;
 
   /* Forget everything at a CODE_LABEL, a volatile asm, or a setjmp.  */
@@ -1346,12 +1349,16 @@ cselib_process_insn (rtx insn)
          && GET_CODE (PATTERN (insn)) == ASM_OPERANDS
          && MEM_VOLATILE_P (PATTERN (insn))))
     {
+      if (find_reg_note (insn, REG_RETVAL, NULL))
+        cselib_current_insn_in_libcall = false;
       clear_table ();
       return;
     }
 
   if (! INSN_P (insn))
     {
+      if (find_reg_note (insn, REG_RETVAL, NULL))
+        cselib_current_insn_in_libcall = false;
       cselib_current_insn = 0;
       return;
     }
@@ -1377,7 +1384,7 @@ cselib_process_insn (rtx insn)
      unlikely to help.  */
   for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
     if (REG_NOTE_KIND (x) == REG_INC)
-      cselib_invalidate_rtx (XEXP (x, 0), NULL_RTX, NULL);
+      cselib_invalidate_rtx (XEXP (x, 0));
 #endif
 
   /* Look for any CLOBBERs in CALL_INSN_FUNCTION_USAGE, but only
@@ -1385,8 +1392,10 @@ cselib_process_insn (rtx insn)
   if (GET_CODE (insn) == CALL_INSN)
     for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
       if (GET_CODE (XEXP (x, 0)) == CLOBBER)
-       cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0), NULL_RTX, NULL);
+       cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0));
 
+  if (find_reg_note (insn, REG_RETVAL, NULL))
+    cselib_current_insn_in_libcall = false;
   cselib_current_insn = 0;
 
   if (n_useless_values > MAX_USELESS_VALUES)
index f86f657..bbe1ffa 100644 (file)
@@ -72,3 +72,4 @@ extern enum machine_mode cselib_reg_set_mode (rtx);
 extern int rtx_equal_for_cselib_p (rtx, rtx);
 extern int references_value_p (rtx, int);
 extern rtx cselib_subst_to_values (rtx);
+extern void cselib_invalidate_rtx (rtx);
index 5a3c135..99a9def 100644 (file)
@@ -434,6 +434,9 @@ static void
 dbxout_function_end (void)
 {
   char lscope_label_name[100];
+
+  /* The Lscope label must be emitted even if we aren't doing anything
+     else; dbxout_block needs it.  */
   /* Convert Ltext into the appropriate format for local labels in case
      the system doesn't insert underscores in front of user generated
      labels.  */
@@ -441,6 +444,16 @@ dbxout_function_end (void)
   (*targetm.asm_out.internal_label) (asmfile, "Lscope", scope_labelno);
   scope_labelno++;
 
+  /* The N_FUN tag at the end of the function is a GNU extension,
+     which may be undesirable, and is unnecessary if we do not have
+     named sections.  */
+  if (!use_gnu_debug_info_extensions
+#if defined(NO_DBX_FUNCTION_END)
+      || NO_DBX_FUNCTION_END
+#endif
+      || !targetm.have_named_sections)
+    return;
+
   /* By convention, GCC will mark the end of a function with an N_FUN
      symbol and an empty string.  */
 #ifdef DBX_OUTPUT_NFUN
@@ -774,12 +787,7 @@ dbxout_function_decl (tree decl)
 #ifdef DBX_OUTPUT_FUNCTION_END
   DBX_OUTPUT_FUNCTION_END (asmfile, decl);
 #endif
-  if (use_gnu_debug_info_extensions
-#if defined(NO_DBX_FUNCTION_END)
-      && ! NO_DBX_FUNCTION_END
-#endif
-      && targetm.have_named_sections)
-    dbxout_function_end ();
+  dbxout_function_end ();
 }
 
 #endif /* DBX_DEBUGGING_INFO  */
@@ -3037,6 +3045,46 @@ dbxout_args (tree args)
     }
 }
 \f
+/* Subroutine of dbxout_block.  Emit an N_LBRAC stab referencing LABEL.
+   BEGIN_LABEL is the name of the beginning of the function, which may
+   be required.  */
+static void
+dbx_output_lbrac (const char *label,
+                 const char *begin_label ATTRIBUTE_UNUSED)
+{
+#ifdef DBX_OUTPUT_LBRAC
+  DBX_OUTPUT_LBRAC (asmfile, label);
+#else
+  fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
+  assemble_name (asmfile, label);
+#if DBX_BLOCKS_FUNCTION_RELATIVE
+  putc ('-', asmfile);
+  assemble_name (asmfile, begin_label);
+#endif
+  fprintf (asmfile, "\n");
+#endif
+}
+
+/* Subroutine of dbxout_block.  Emit an N_RBRAC stab referencing LABEL.
+   BEGIN_LABEL is the name of the beginning of the function, which may
+   be required.  */
+static void
+dbx_output_rbrac (const char *label,
+                 const char *begin_label ATTRIBUTE_UNUSED)
+{
+#ifdef DBX_OUTPUT_RBRAC
+  DBX_OUTPUT_RBRAC (asmfile, label);
+#else
+  fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
+  assemble_name (asmfile, label);
+#if DBX_BLOCKS_FUNCTION_RELATIVE
+  putc ('-', asmfile);
+  assemble_name (asmfile, begin_label);
+#endif
+  fprintf (asmfile, "\n");
+#endif
+}
+
 /* Output everything about a symbol block (a BLOCK node
    that represents a scope level),
    including recursive output of contained blocks.
@@ -3057,15 +3105,11 @@ dbxout_args (tree args)
 static void
 dbxout_block (tree block, int depth, tree args)
 {
-  int blocknum = -1;
-
-#if DBX_BLOCKS_FUNCTION_RELATIVE
   const char *begin_label;
   if (current_function_func_begin_label != NULL_TREE)
     begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
   else
     begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
-#endif
 
   while (block)
     {
@@ -3073,6 +3117,7 @@ dbxout_block (tree block, int depth, tree args)
       if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
        {
          int did_output;
+         int blocknum = BLOCK_NUMBER (block);
 
          /* In dbx format, the syms of a block come before the N_LBRAC.
             If nothing is output, we don't need the N_LBRAC, either.  */
@@ -3086,11 +3131,20 @@ dbxout_block (tree block, int depth, tree args)
             the block.  Use the block's tree-walk order to generate
             the assembler symbols LBBn and LBEn
             that final will define around the code in this block.  */
-         if (depth > 0 && did_output)
+         if (did_output)
            {
              char buf[20];
-             blocknum = BLOCK_NUMBER (block);
-             ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
+             const char *scope_start;
+
+             if (depth == 0)
+               /* The outermost block doesn't get LBB labels; use
+                  the function symbol.  */
+               scope_start = begin_label;
+             else
+               {
+                 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
+                 scope_start = buf;
+               }
 
              if (BLOCK_HANDLER_BLOCK (block))
                {
@@ -3100,44 +3154,30 @@ dbxout_block (tree block, int depth, tree args)
                    {
                      fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
                               IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
-                     assemble_name (asmfile, buf);
+                     assemble_name (asmfile, scope_start);
                      fprintf (asmfile, "\n");
                      decl = TREE_CHAIN (decl);
                    }
                }
-
-#ifdef DBX_OUTPUT_LBRAC
-             DBX_OUTPUT_LBRAC (asmfile, buf);
-#else
-             fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
-             assemble_name (asmfile, buf);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
-             putc ('-', asmfile);
-             assemble_name (asmfile, begin_label);
-#endif
-             fprintf (asmfile, "\n");
-#endif
+             dbx_output_lbrac (scope_start, begin_label);
            }
 
          /* Output the subblocks.  */
          dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
 
          /* Refer to the marker for the end of the block.  */
-         if (depth > 0 && did_output)
+         if (did_output)
            {
-             char buf[20];
-             ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
-#ifdef DBX_OUTPUT_RBRAC
-             DBX_OUTPUT_RBRAC (asmfile, buf);
-#else
-             fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
-             assemble_name (asmfile, buf);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
-             putc ('-', asmfile);
-             assemble_name (asmfile, begin_label);
-#endif
-             fprintf (asmfile, "\n");
-#endif
+             char buf[100];
+             if (depth == 0)
+               /* The outermost block doesn't get LBE labels;
+                  use the "scope" label which will be emitted
+                  by dbxout_function_end.  */
+               ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
+             else
+               ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
+
+             dbx_output_rbrac (buf, begin_label);
            }
        }
       block = BLOCK_CHAIN (block);
index d9613ef..9e10af9 100644 (file)
@@ -1,5 +1,5 @@
 @c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-@c 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
+@c 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
 @c This is part of the GCC manual.
 @c For copying conditions, see the file gcc.texi.
 
@@ -76,8 +76,8 @@ compiler bug.
 @item
 If the compiler does not produce an error message for invalid input,
 that is a compiler bug.  However, you should note that your idea of
-``invalid input'' might be my idea of ``an extension'' or ``support
-for traditional practice''.
+``invalid input'' might be someone else's idea of ``an extension'' or
+``support for traditional practice''.
 
 @item
 If you are an experienced user of one of the languages GCC supports, your
@@ -88,7 +88,7 @@ suggestions for improvement of GCC are welcome in any case.
 @section How and where to Report Bugs
 @cindex compiler bugs, reporting
 
-Bugs should be reported to our bug database.  Please refer to
+Bugs should be reported to the GCC bug database.  Please refer to
 @uref{http://gcc.gnu.org/bugs.html} for up-to-date instructions how to
 submit bug reports.  Copies of this file in HTML (@file{bugs.html}) and
 plain text (@file{BUGS}) are also part of GCC releases.
index 39b3152..f97de5b 100644 (file)
@@ -1,4 +1,4 @@
-@c Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+@c Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
 @c This is part of the GCC manual.
 @c For copying conditions, see the file gcc.texi.
 
@@ -34,8 +34,8 @@ different system.  Some people call this a @dfn{host-x-host},
 @dfn{crossed native}, or @dfn{cross-built native}.  If build and target
 are the same, but host is different, you are using a cross compiler to
 build a cross compiler that produces code for the machine you're
-building on.  This is rare, so there is no common way of describing it
-(although I propose calling it a @dfn{crossback}).
+building on.  This is rare, so there is no common way of describing it.
+There is a proposal to call this a @dfn{crossback}.
 
 If build and host are the same, the GCC you are building will also be
 used to build the target libraries (like @code{libstdc++}).  If build and host
index c07f265..8c24193 100644 (file)
@@ -59,7 +59,7 @@ Jon Beniston for his Microsoft Windows port of Java.
 
 @item
 Daniel Berlin for better DWARF2 support, faster/better optimizations,
-improved alias analysis, plus migrating us to Bugzilla.
+improved alias analysis, plus migrating GCC to Bugzilla.
 
 @item
 Geoff Berry for his Java object serialization work and various patches.
@@ -84,7 +84,7 @@ Eric Botcazou for fixing middle- and backend bugs left and right.
 
 @item
 Per Bothner for his direction via the steering committee and various
-improvements to our infrastructure for supporting new languages.  Chill
+improvements to the infrastructure for supporting new languages.  Chill
 front end implementation.  Initial implementations of
 cpplib, fix-header, config.guess, libio, and past C++ library (libg++)
 maintainer.  Dreaming up, designing and implementing much of GCJ.
@@ -151,7 +151,7 @@ Eric Christopher for his Java porting help and clean-ups.
 Branko Cibej for more warning contributions.
 
 @item
-The @uref{http://www.classpath.org,,GNU Classpath project}
+The @uref{http://www.gnu.org/software/classpath/,,GNU Classpath project}
 for all of their merged runtime code.
 
 @item
@@ -289,7 +289,7 @@ via the steering committee.
 Anthony Green for his @option{-Os} contributions and Java front end work.
 
 @item
-Stu Grossman for gdb hacking, allowing GCJ developers to debug our code.
+Stu Grossman for gdb hacking, allowing GCJ developers to debug Java code.
 
 @item
 Michael K. Gschwind contributed the port to the PDP-11.
@@ -340,7 +340,7 @@ Kazu Hirata for caring and feeding the Renesas H8/300 port and various fixes.
 
 @item
 Manfred Hollstein for his ongoing work to keep the m88k alive, lots
-of testing and bug fixing, particularly of our configury code.
+of testing and bug fixing, particularly of GCC configury code.
 
 @item
 Steve Holmgren for MachTen patches.
@@ -627,7 +627,7 @@ amazing testing work, including keeping libtool issues sane and happy.
 Melissa O'Neill for various NeXT fixes.
 
 @item
-Rainer Orth for random MIPS work, including improvements to our o32
+Rainer Orth for random MIPS work, including improvements to GCC's o32
 ABI support, improvements to dejagnu's MIPS support, Java configuration
 clean-ups and porting work, etc.
 
@@ -690,7 +690,7 @@ Craig Rodrigues for processing tons of bug reports.
 Gavin Romig-Koch for lots of behind the scenes MIPS work.
 
 @item
-Ken Rose for fixes to our delay slot filling code.
+Ken Rose for fixes to GCC's delay slot filling code.
 
 @item
 Paul Rubin wrote most of the preprocessor.
@@ -752,7 +752,7 @@ folding and help with the original VAX & m68k ports.
 
 @item
 Kenny Simpson for prompting libstdc++ fixes due to defect reports from
-the LWG (thereby keeping us in line with updates from the ISO).
+the LWG (thereby keeping GCC in line with updates from the ISO).
 
 @item
 Franz Sirl for his ongoing work with making the PPC port stable
index 0aec268..a90c048 100644 (file)
@@ -1,5 +1,5 @@
 @c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-@c 1999, 2000, 2001 Free Software Foundation, Inc.
+@c 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
 @c This is part of the GCC manual.
 @c For copying conditions, see the file gcc.texi.
 
@@ -7,7 +7,7 @@
 @chapter Contributing to GCC Development
 
 If you would like to help pretest GCC releases to assure they work well,
-our current development sources are available by CVS (see
+current development sources are available by CVS (see
 @uref{http://gcc.gnu.org/cvs.html}).  Source and binary snapshots are
 also available for FTP; see @uref{http://gcc.gnu.org/snapshots.html}.
 
index 5d1cb9b..3697887 100644 (file)
@@ -1894,7 +1894,8 @@ or a C++ compiler.  This macro is similar to @code{__STDC_VERSION__}, in
 that it expands to a version number.  A fully conforming implementation
 of the 1998 C++ standard will define this macro to @code{199711L}.  The
 GNU C++ compiler is not yet fully conforming, so it uses @code{1}
-instead.  We hope to complete our implementation in the near future.
+instead.  It is hoped to complete the implementation of standard C++
+in the near future.
 
 @item __OBJC__
 This macro is defined, with value 1, when the Objective-C compiler is in
@@ -2538,7 +2539,7 @@ definition.  Recall that all macro definitions are rescanned for more
 macros to replace.  If the self-reference were considered a use of the
 macro, it would produce an infinitely large expansion.  To prevent this,
 the self-reference is not considered a macro call.  It is passed into
-the preprocessor output unchanged.  Let's consider an example:
+the preprocessor output unchanged.  Consider an example:
 
 @smallexample
 #define foo (4 + foo)
@@ -2960,9 +2961,6 @@ expression, and may give different results in some cases.  If the value
 comes out to be nonzero, the @samp{#if} succeeds and the @var{controlled
 text} is included; otherwise it is skipped.
 
-If @var{expression} is not correctly formed, GCC issues an error and
-treats the conditional as having failed.
-
 @node Defined
 @subsection Defined
 
@@ -3832,10 +3830,10 @@ pragmas.
 
 CPP has a small number of internal limits.  This section lists the
 limits which the C standard requires to be no lower than some minimum,
-and all the others we are aware of.  We intend there to be as few limits
+and all the others known.  It is intended that there should be as few limits
 as possible.  If you encounter an undocumented or inconvenient limit,
-please report that to us as a bug.  (See the section on reporting bugs in
-the GCC manual.)
+please report that as a bug.  @xref{Bugs, , Reporting Bugs, gcc, Using
+the GNU Compiler Collection (GCC)}.
 
 Where we say something is limited @dfn{only by available memory}, that
 means that internal data structures impose no intrinsic limit, and space
index 3f3d9af..9f5863c 100644 (file)
@@ -16,7 +16,7 @@
 @ifinfo
 This file documents the internals of the GNU C Preprocessor.
 
-Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
+Copyright 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
 
 Permission is granted to make and distribute verbatim copies of
 this manual provided the copyright notice and this permission notice
@@ -47,7 +47,7 @@ into another language, under the above conditions for modified versions.
 @page
 @vskip 0pt plus 1filll
 @c man begin COPYRIGHT
-Copyright @copyright{} 2000, 2001, 2002
+Copyright @copyright{} 2000, 2001, 2002, 2004
 Free Software Foundation, Inc.
 
 Permission is granted to make and distribute verbatim copies of
@@ -226,7 +226,7 @@ foo
 @end smallexample
 
 This is a good example of the subtlety of getting token spacing correct
-in the preprocessor; there are plenty of tests in the test suite for
+in the preprocessor; there are plenty of tests in the testsuite for
 corner cases like this.
 
 The lexer is written to treat each of @samp{\r}, @samp{\n}, @samp{\r\n}
@@ -368,8 +368,8 @@ chaining a new token run on to the end of the existing one.
 
 The tokens forming a macro's replacement list are collected by the
 @code{#define} handler, and placed in storage that is only freed by
-@code{cpp_destroy}.  So if a macro is expanded in our line of tokens,
-the pointers to the tokens of its expansion that we return will always
+@code{cpp_destroy}.  So if a macro is expanded in the line of tokens,
+the pointers to the tokens of its expansion that are returned will always
 remain valid.  However, macros are a little trickier than that, since
 they give rise to three sources of fresh tokens.  They are the built-in
 macros like @code{__LINE__}, and the @samp{#} and @samp{##} operators
@@ -640,8 +640,8 @@ is safe.
 @cindex spacing
 @cindex token spacing
 
-First, let's look at an issue that only concerns the stand-alone
-preprocessor: we want to guarantee that re-reading its preprocessed
+First, consider an issue that only concerns the stand-alone
+preprocessor: there needs to be a guarantee that re-reading its preprocessed
 output results in an identical token stream.  Without taking special
 measures, this might not be the case because of macro substitution.
 For example:
@@ -670,7 +670,7 @@ expansion, but accidental pasting can occur in many places: both before
 and after each macro replacement, each argument replacement, and
 additionally each token created by the @samp{#} and @samp{##} operators.
 
-Let's look at how the preprocessor gets whitespace output correct
+Look at how the preprocessor gets whitespace output correct
 normally.  The @code{cpp_token} structure contains a flags byte, and one
 of those flags is @code{PREV_WHITE}.  This is flagged by the lexer, and
 indicates that the token was preceded by whitespace of some form other
@@ -719,11 +719,11 @@ a macro's first replacement token expands straight into another macro.
 
 Here, two padding tokens are generated with sources the @samp{foo} token
 between the brackets, and the @samp{bar} token from foo's replacement
-list, respectively.  Clearly the first padding token is the one we
-should use, so our output code should contain a rule that the first
+list, respectively.  Clearly the first padding token is the one to
+use, so the output code should contain a rule that the first
 padding token in a sequence is the one that matters.
 
-But what if we happen to leave a macro expansion?  Adjusting the above
+But what if a macro expansion is left?  Adjusting the above
 example slightly:
 
 @smallexample
index fb8f5c7..6e784de 100644 (file)
@@ -17,10 +17,14 @@ Predefine @var{name} as a macro, with definition @code{1}.
 
 @item -D @var{name}=@var{definition}
 Predefine @var{name} as a macro, with definition @var{definition}.
-There are no restrictions on the contents of @var{definition}, but if
-you are invoking the preprocessor from a shell or shell-like program you
-may need to use the shell's quoting syntax to protect characters such as
-spaces that have a meaning in the shell syntax.
+The contents of @var{definition} are tokenized and processed as if
+they appeared during translation phase three in a @samp{#define}
+directive.  In particular, the definition will be truncated by
+embedded newline characters.
+
+If you are invoking the preprocessor from a shell or shell-like
+program you may need to use the shell's quoting syntax to protect
+characters such as spaces that have a meaning in the shell syntax.
 
 If you wish to define a function-like macro on the command line, write
 its argument list with surrounding parentheses before the equals sign
index 9c3ea0a..0b4cd44 100644 (file)
@@ -524,7 +524,7 @@ follows:
 @cindex side effects, macro argument
 But this definition computes either @var{a} or @var{b} twice, with bad
 results if the operand has side effects.  In GNU C, if you know the
-type of the operands (here let's assume @code{int}), you can define
+type of the operands (here taken as @code{int}), you can define
 the macro safely as follows:
 
 @smallexample
@@ -1021,7 +1021,7 @@ char *y[4];
 @end smallexample
 
 To see the meaning of the declaration using @code{typeof}, and why it
-might be a useful way to write, let's rewrite it with these macros:
+might be a useful way to write, rewrite it with these macros:
 
 @smallexample
 #define pointer(T)  typeof(T *)
@@ -6121,139 +6121,264 @@ v2si __builtin_ia32_pswapdsi (v2si)
 @node PowerPC AltiVec Built-in Functions
 @subsection PowerPC AltiVec Built-in Functions
 
-These built-in functions are available for the PowerPC family
-of computers, depending on the command-line switches used.
+GCC provides an interface for the PowerPC family of processors to access
+the AltiVec operations described in Motorola's AltiVec Programming
+Interface Manual.  The interface is made available by including
+@code{<altivec.h>} and using @option{-maltivec} and
+@option{-mabi=altivec}.  The interface supports the following vector
+types.
 
-The following machine modes are available for use with AltiVec built-in
-functions (@pxref{Vector Extensions}): @code{V4SI} for a vector of four
-32-bit integers, @code{V4SF} for a vector of four 32-bit floating point
-numbers, @code{V8HI} for a vector of eight 16-bit integers, and
-@code{V16QI} for a vector of sixteen 8-bit integers.
+@smallexample
+vector unsigned char
+vector signed char
+vector bool char
 
-The following functions are made available by including
-@code{<altivec.h>} and using @option{-maltivec} and
-@option{-mabi=altivec}.  The functions implement the functionality
-described in Motorola's AltiVec Programming Interface Manual.
+vector unsigned short
+vector signed short
+vector bool short
+vector pixel
+
+vector unsigned int
+vector signed int
+vector bool int
+vector float
+@end smallexample
+
+GCC's implementation of the high-level language interface available from
+C and C++ code differs from Motorola's documentation in several ways.
+
+@itemize @bullet
+
+@item
+A vector constant is a list of constant expressions within curly braces.
+
+@item
+A vector initializer requires no cast if the vector constant is of the
+same type as the variable it is initializing.
 
-There are a few differences from Motorola's documentation and GCC's
-implementation.  Vector constants are done with curly braces (not
-parentheses).  Vector initializers require no casts if the vector
-constant is of the same type as the variable it is initializing.  The
-@code{vector bool} type is deprecated and will be discontinued in
-further revisions.  Use @code{vector signed} instead.  If @code{signed}
-or @code{unsigned} is omitted, the vector type will default to
-@code{signed}.  Lastly, all overloaded functions are implemented with macros
-for the C implementation.  So code the following example will not work:
+@item
+If @code{signed} or @code{unsigned} is omitted, the vector type defaults
+to @code{signed} for @code{vector int} or @code{vector short} and to
+@code{unsigned} for @code{vector char}.
+                                                                                
+@item
+Compiling with @option{-maltivec} adds keywords @code{__vector},
+@code{__pixel}, and @code{__bool}.  Macros @option{vector},
+@code{pixel}, and @code{bool} are defined in @code{<altivec.h>} and can
+be undefined.
+                                                                                
+@item
+GCC allows using a @code{typedef} name as the type specifier for a
+vector type.
+
+@item
+For C, overloaded functions are implemented with macros so the following
+does not work:
 
 @smallexample
   vec_add ((vector signed int)@{1, 2, 3, 4@}, foo);
 @end smallexample
 
-Since vec_add is a macro, the vector constant in the above example will
-be treated as four different arguments.  Wrap the entire argument in
-parentheses for this to work.  The C++ implementation does not use
-macros.
+Since @code{vec_add} is a macro, the vector constant in the example
+is treated as four separate arguments.  Wrap the entire argument in
+parentheses for this to work.
+@end itemize
 
 @emph{Note:} Only the @code{<altivec.h>} interface is supported.
 Internally, GCC uses built-in functions to achieve the functionality in
 the aforementioned header file, but they are not supported and are
 subject to change without notice.
 
-@smallexample
-vector signed char vec_abs (vector signed char, vector signed char);
-vector signed short vec_abs (vector signed short, vector signed short);
-vector signed int vec_abs (vector signed int, vector signed int);
-vector signed float vec_abs (vector signed float, vector signed float);
+The following interfaces are supported for the generic and specific
+AltiVec operations and the AltiVec predicates.  In cases where there
+is a direct mapping between generic and specific operations, only the
+generic names are shown here, although the specific operations can also
+be used.
 
-vector signed char vec_abss (vector signed char, vector signed char);
-vector signed short vec_abss (vector signed short, vector signed short);
+Arguments that are documented as @code{const int} require literal
+integral values within the range required for that operation.
 
-vector signed char vec_add (vector signed char, vector signed char);
-vector unsigned char vec_add (vector signed char, vector unsigned char);
+@smallexample
+vector signed char vec_abs (vector signed char);
+vector signed short vec_abs (vector signed short);
+vector signed int vec_abs (vector signed int);
+vector float vec_abs (vector float);
 
-vector unsigned char vec_add (vector unsigned char, vector signed char);
+vector signed char vec_abss (vector signed char);
+vector signed short vec_abss (vector signed short);
+vector signed int vec_abss (vector signed int);
 
+vector signed char vec_add (vector bool char, vector signed char);
+vector signed char vec_add (vector signed char, vector bool char);
+vector signed char vec_add (vector signed char, vector signed char);
+vector unsigned char vec_add (vector bool char, vector unsigned char);
+vector unsigned char vec_add (vector unsigned char, vector bool char);
 vector unsigned char vec_add (vector unsigned char,
                               vector unsigned char);
+vector signed short vec_add (vector bool short, vector signed short);
+vector signed short vec_add (vector signed short, vector bool short);
 vector signed short vec_add (vector signed short, vector signed short);
-vector unsigned short vec_add (vector signed short,
+vector unsigned short vec_add (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_add (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_add (vector unsigned short,
                                vector unsigned short);
+vector signed int vec_add (vector bool int, vector signed int);
+vector signed int vec_add (vector signed int, vector bool int);
 vector signed int vec_add (vector signed int, vector signed int);
-vector unsigned int vec_add (vector signed int, vector unsigned int);
-vector unsigned int vec_add (vector unsigned int, vector signed int);
+vector unsigned int vec_add (vector bool int, vector unsigned int);
+vector unsigned int vec_add (vector unsigned int, vector bool int);
 vector unsigned int vec_add (vector unsigned int, vector unsigned int);
 vector float vec_add (vector float, vector float);
 
+vector float vec_vaddfp (vector float, vector float);
+
+vector signed int vec_vadduwm (vector bool int, vector signed int);
+vector signed int vec_vadduwm (vector signed int, vector bool int);
+vector signed int vec_vadduwm (vector signed int, vector signed int);
+vector unsigned int vec_vadduwm (vector bool int, vector unsigned int);
+vector unsigned int vec_vadduwm (vector unsigned int, vector bool int);
+vector unsigned int vec_vadduwm (vector unsigned int,
+                                 vector unsigned int);
+
+vector signed short vec_vadduhm (vector bool short,
+                                 vector signed short);
+vector signed short vec_vadduhm (vector signed short,
+                                 vector bool short);
+vector signed short vec_vadduhm (vector signed short,
+                                 vector signed short);
+vector unsigned short vec_vadduhm (vector bool short,
+                                   vector unsigned short);
+vector unsigned short vec_vadduhm (vector unsigned short,
+                                   vector bool short);
+vector unsigned short vec_vadduhm (vector unsigned short,
+                                   vector unsigned short);
+
+vector signed char vec_vaddubm (vector bool char, vector signed char);
+vector signed char vec_vaddubm (vector signed char, vector bool char);
+vector signed char vec_vaddubm (vector signed char, vector signed char);
+vector unsigned char vec_vaddubm (vector bool char,
+                                  vector unsigned char);
+vector unsigned char vec_vaddubm (vector unsigned char,
+                                  vector bool char);
+vector unsigned char vec_vaddubm (vector unsigned char,
+                                  vector unsigned char);
+
 vector unsigned int vec_addc (vector unsigned int, vector unsigned int);
 
-vector unsigned char vec_adds (vector signed char,
-                               vector unsigned char);
-vector unsigned char vec_adds (vector unsigned char,
-                               vector signed char);
+vector unsigned char vec_adds (vector bool char, vector unsigned char);
+vector unsigned char vec_adds (vector unsigned char, vector bool char);
 vector unsigned char vec_adds (vector unsigned char,
                                vector unsigned char);
+vector signed char vec_adds (vector bool char, vector signed char);
+vector signed char vec_adds (vector signed char, vector bool char);
 vector signed char vec_adds (vector signed char, vector signed char);
-vector unsigned short vec_adds (vector signed short,
+vector unsigned short vec_adds (vector bool short,
                                 vector unsigned short);
 vector unsigned short vec_adds (vector unsigned short,
-                                vector signed short);
+                                vector bool short);
 vector unsigned short vec_adds (vector unsigned short,
                                 vector unsigned short);
+vector signed short vec_adds (vector bool short, vector signed short);
+vector signed short vec_adds (vector signed short, vector bool short);
 vector signed short vec_adds (vector signed short, vector signed short);
-
-vector unsigned int vec_adds (vector signed int, vector unsigned int);
-vector unsigned int vec_adds (vector unsigned int, vector signed int);
+vector unsigned int vec_adds (vector bool int, vector unsigned int);
+vector unsigned int vec_adds (vector unsigned int, vector bool int);
 vector unsigned int vec_adds (vector unsigned int, vector unsigned int);
-
+vector signed int vec_adds (vector bool int, vector signed int);
+vector signed int vec_adds (vector signed int, vector bool int);
 vector signed int vec_adds (vector signed int, vector signed int);
 
+vector signed int vec_vaddsws (vector bool int, vector signed int);
+vector signed int vec_vaddsws (vector signed int, vector bool int);
+vector signed int vec_vaddsws (vector signed int, vector signed int);
+
+vector unsigned int vec_vadduws (vector bool int, vector unsigned int);
+vector unsigned int vec_vadduws (vector unsigned int, vector bool int);
+vector unsigned int vec_vadduws (vector unsigned int,
+                                 vector unsigned int);
+
+vector signed short vec_vaddshs (vector bool short,
+                                 vector signed short);
+vector signed short vec_vaddshs (vector signed short,
+                                 vector bool short);
+vector signed short vec_vaddshs (vector signed short,
+                                 vector signed short);
+
+vector unsigned short vec_vadduhs (vector bool short,
+                                   vector unsigned short);
+vector unsigned short vec_vadduhs (vector unsigned short,
+                                   vector bool short);
+vector unsigned short vec_vadduhs (vector unsigned short,
+                                   vector unsigned short);
+
+vector signed char vec_vaddsbs (vector bool char, vector signed char);
+vector signed char vec_vaddsbs (vector signed char, vector bool char);
+vector signed char vec_vaddsbs (vector signed char, vector signed char);
+
+vector unsigned char vec_vaddubs (vector bool char,
+                                  vector unsigned char);
+vector unsigned char vec_vaddubs (vector unsigned char,
+                                  vector bool char);
+vector unsigned char vec_vaddubs (vector unsigned char,
+                                  vector unsigned char);
+
 vector float vec_and (vector float, vector float);
-vector float vec_and (vector float, vector signed int);
-vector float vec_and (vector signed int, vector float);
+vector float vec_and (vector float, vector bool int);
+vector float vec_and (vector bool int, vector float);
+vector bool int vec_and (vector bool int, vector bool int);
+vector signed int vec_and (vector bool int, vector signed int);
+vector signed int vec_and (vector signed int, vector bool int);
 vector signed int vec_and (vector signed int, vector signed int);
-vector unsigned int vec_and (vector signed int, vector unsigned int);
-vector unsigned int vec_and (vector unsigned int, vector signed int);
+vector unsigned int vec_and (vector bool int, vector unsigned int);
+vector unsigned int vec_and (vector unsigned int, vector bool int);
 vector unsigned int vec_and (vector unsigned int, vector unsigned int);
+vector bool short vec_and (vector bool short, vector bool short);
+vector signed short vec_and (vector bool short, vector signed short);
+vector signed short vec_and (vector signed short, vector bool short);
 vector signed short vec_and (vector signed short, vector signed short);
-vector unsigned short vec_and (vector signed short,
+vector unsigned short vec_and (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_and (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_and (vector unsigned short,
                                vector unsigned short);
+vector signed char vec_and (vector bool char, vector signed char);
+vector bool char vec_and (vector bool char, vector bool char);
+vector signed char vec_and (vector signed char, vector bool char);
 vector signed char vec_and (vector signed char, vector signed char);
-vector unsigned char vec_and (vector signed char, vector unsigned char);
-
-vector unsigned char vec_and (vector unsigned char, vector signed char);
-
+vector unsigned char vec_and (vector bool char, vector unsigned char);
+vector unsigned char vec_and (vector unsigned char, vector bool char);
 vector unsigned char vec_and (vector unsigned char,
                               vector unsigned char);
 
 vector float vec_andc (vector float, vector float);
-vector float vec_andc (vector float, vector signed int);
-vector float vec_andc (vector signed int, vector float);
+vector float vec_andc (vector float, vector bool int);
+vector float vec_andc (vector bool int, vector float);
+vector bool int vec_andc (vector bool int, vector bool int);
+vector signed int vec_andc (vector bool int, vector signed int);
+vector signed int vec_andc (vector signed int, vector bool int);
 vector signed int vec_andc (vector signed int, vector signed int);
-vector unsigned int vec_andc (vector signed int, vector unsigned int);
-vector unsigned int vec_andc (vector unsigned int, vector signed int);
+vector unsigned int vec_andc (vector bool int, vector unsigned int);
+vector unsigned int vec_andc (vector unsigned int, vector bool int);
 vector unsigned int vec_andc (vector unsigned int, vector unsigned int);
-
+vector bool short vec_andc (vector bool short, vector bool short);
+vector signed short vec_andc (vector bool short, vector signed short);
+vector signed short vec_andc (vector signed short, vector bool short);
 vector signed short vec_andc (vector signed short, vector signed short);
-
-vector unsigned short vec_andc (vector signed short,
+vector unsigned short vec_andc (vector bool short,
                                 vector unsigned short);
 vector unsigned short vec_andc (vector unsigned short,
-                                vector signed short);
+                                vector bool short);
 vector unsigned short vec_andc (vector unsigned short,
                                 vector unsigned short);
+vector signed char vec_andc (vector bool char, vector signed char);
+vector bool char vec_andc (vector bool char, vector bool char);
+vector signed char vec_andc (vector signed char, vector bool char);
 vector signed char vec_andc (vector signed char, vector signed char);
-vector unsigned char vec_andc (vector signed char,
-                               vector unsigned char);
-vector unsigned char vec_andc (vector unsigned char,
-                               vector signed char);
+vector unsigned char vec_andc (vector bool char, vector unsigned char);
+vector unsigned char vec_andc (vector unsigned char, vector bool char);
 vector unsigned char vec_andc (vector unsigned char,
                                vector unsigned char);
 
@@ -6266,185 +6391,471 @@ vector signed short vec_avg (vector signed short, vector signed short);
 vector unsigned int vec_avg (vector unsigned int, vector unsigned int);
 vector signed int vec_avg (vector signed int, vector signed int);
 
+vector signed int vec_vavgsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vavguw (vector unsigned int,
+                                vector unsigned int);
+
+vector signed short vec_vavgsh (vector signed short,
+                                vector signed short);
+
+vector unsigned short vec_vavguh (vector unsigned short,
+                                  vector unsigned short);
+
+vector signed char vec_vavgsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vavgub (vector unsigned char,
+                                 vector unsigned char);
+
 vector float vec_ceil (vector float);
 
 vector signed int vec_cmpb (vector float, vector float);
 
-vector signed char vec_cmpeq (vector signed char, vector signed char);
-vector signed char vec_cmpeq (vector unsigned char,
-                              vector unsigned char);
-vector signed short vec_cmpeq (vector signed short,
-                               vector signed short);
-vector signed short vec_cmpeq (vector unsigned short,
-                               vector unsigned short);
-vector signed int vec_cmpeq (vector signed int, vector signed int);
-vector signed int vec_cmpeq (vector unsigned int, vector unsigned int);
-vector signed int vec_cmpeq (vector float, vector float);
+vector bool char vec_cmpeq (vector signed char, vector signed char);
+vector bool char vec_cmpeq (vector unsigned char, vector unsigned char);
+vector bool short vec_cmpeq (vector signed short, vector signed short);
+vector bool short vec_cmpeq (vector unsigned short,
+                             vector unsigned short);
+vector bool int vec_cmpeq (vector signed int, vector signed int);
+vector bool int vec_cmpeq (vector unsigned int, vector unsigned int);
+vector bool int vec_cmpeq (vector float, vector float);
 
-vector signed int vec_cmpge (vector float, vector float);
+vector bool int vec_vcmpeqfp (vector float, vector float);
 
-vector signed char vec_cmpgt (vector unsigned char,
-                              vector unsigned char);
-vector signed char vec_cmpgt (vector signed char, vector signed char);
-vector signed short vec_cmpgt (vector unsigned short,
-                               vector unsigned short);
-vector signed short vec_cmpgt (vector signed short,
-                               vector signed short);
-vector signed int vec_cmpgt (vector unsigned int, vector unsigned int);
-vector signed int vec_cmpgt (vector signed int, vector signed int);
-vector signed int vec_cmpgt (vector float, vector float);
+vector bool int vec_vcmpequw (vector signed int, vector signed int);
+vector bool int vec_vcmpequw (vector unsigned int, vector unsigned int);
 
-vector signed int vec_cmple (vector float, vector float);
+vector bool short vec_vcmpequh (vector signed short,
+                                vector signed short);
+vector bool short vec_vcmpequh (vector unsigned short,
+                                vector unsigned short);
 
-vector signed char vec_cmplt (vector unsigned char,
-                              vector unsigned char);
-vector signed char vec_cmplt (vector signed char, vector signed char);
-vector signed short vec_cmplt (vector unsigned short,
-                               vector unsigned short);
-vector signed short vec_cmplt (vector signed short,
-                               vector signed short);
-vector signed int vec_cmplt (vector unsigned int, vector unsigned int);
-vector signed int vec_cmplt (vector signed int, vector signed int);
-vector signed int vec_cmplt (vector float, vector float);
+vector bool char vec_vcmpequb (vector signed char, vector signed char);
+vector bool char vec_vcmpequb (vector unsigned char,
+                               vector unsigned char);
 
-vector float vec_ctf (vector unsigned int, const char);
-vector float vec_ctf (vector signed int, const char);
+vector bool int vec_cmpge (vector float, vector float);
 
-vector signed int vec_cts (vector float, const char);
+vector bool char vec_cmpgt (vector unsigned char, vector unsigned char);
+vector bool char vec_cmpgt (vector signed char, vector signed char);
+vector bool short vec_cmpgt (vector unsigned short,
+                             vector unsigned short);
+vector bool short vec_cmpgt (vector signed short, vector signed short);
+vector bool int vec_cmpgt (vector unsigned int, vector unsigned int);
+vector bool int vec_cmpgt (vector signed int, vector signed int);
+vector bool int vec_cmpgt (vector float, vector float);
 
-vector unsigned int vec_ctu (vector float, const char);
+vector bool int vec_vcmpgtfp (vector float, vector float);
 
-void vec_dss (const char);
+vector bool int vec_vcmpgtsw (vector signed int, vector signed int);
+
+vector bool int vec_vcmpgtuw (vector unsigned int, vector unsigned int);
+
+vector bool short vec_vcmpgtsh (vector signed short,
+                                vector signed short);
+
+vector bool short vec_vcmpgtuh (vector unsigned short,
+                                vector unsigned short);
+
+vector bool char vec_vcmpgtsb (vector signed char, vector signed char);
+
+vector bool char vec_vcmpgtub (vector unsigned char,
+                               vector unsigned char);
+
+vector bool int vec_cmple (vector float, vector float);
+
+vector bool char vec_cmplt (vector unsigned char, vector unsigned char);
+vector bool char vec_cmplt (vector signed char, vector signed char);
+vector bool short vec_cmplt (vector unsigned short,
+                             vector unsigned short);
+vector bool short vec_cmplt (vector signed short, vector signed short);
+vector bool int vec_cmplt (vector unsigned int, vector unsigned int);
+vector bool int vec_cmplt (vector signed int, vector signed int);
+vector bool int vec_cmplt (vector float, vector float);
+
+vector float vec_ctf (vector unsigned int, const int);
+vector float vec_ctf (vector signed int, const int);
+
+vector float vec_vcfsx (vector signed int, const int);
+
+vector float vec_vcfux (vector unsigned int, const int);
+
+vector signed int vec_cts (vector float, const int);
+
+vector unsigned int vec_ctu (vector float, const int);
+
+void vec_dss (const int);
 
 void vec_dssall (void);
 
-void vec_dst (void *, int, const char);
-
-void vec_dstst (void *, int, const char);
-
-void vec_dststt (void *, int, const char);
-
-void vec_dstt (void *, int, const char);
-
-vector float vec_expte (vector float, vector float);
-
-vector float vec_floor (vector float, vector float);
-
-vector float vec_ld (int, vector float *);
-vector float vec_ld (int, float *):
-vector signed int vec_ld (int, int *);
-vector signed int vec_ld (int, vector signed int *);
-vector unsigned int vec_ld (int, vector unsigned int *);
-vector unsigned int vec_ld (int, unsigned int *);
-vector signed short vec_ld (int, short *, vector signed short *);
-vector unsigned short vec_ld (int, unsigned short *,
-                              vector unsigned short *);
-vector signed char vec_ld (int, signed char *);
-vector signed char vec_ld (int, vector signed char *);
-vector unsigned char vec_ld (int, unsigned char *);
-vector unsigned char vec_ld (int, vector unsigned char *);
-
-vector signed char vec_lde (int, signed char *);
-vector unsigned char vec_lde (int, unsigned char *);
-vector signed short vec_lde (int, short *);
-vector unsigned short vec_lde (int, unsigned short *);
-vector float vec_lde (int, float *);
-vector signed int vec_lde (int, int *);
-vector unsigned int vec_lde (int, unsigned int *);
-
-void float vec_ldl (int, float *);
-void float vec_ldl (int, vector float *);
-void signed int vec_ldl (int, vector signed int *);
-void signed int vec_ldl (int, int *);
-void unsigned int vec_ldl (int, unsigned int *);
-void unsigned int vec_ldl (int, vector unsigned int *);
-void signed short vec_ldl (int, vector signed short *);
-void signed short vec_ldl (int, short *);
-void unsigned short vec_ldl (int, vector unsigned short *);
-void unsigned short vec_ldl (int, unsigned short *);
-void signed char vec_ldl (int, vector signed char *);
-void signed char vec_ldl (int, signed char *);
-void unsigned char vec_ldl (int, vector unsigned char *);
-void unsigned char vec_ldl (int, unsigned char *);
+void vec_dst (const vector unsigned char *, int, const int);
+void vec_dst (const vector signed char *, int, const int);
+void vec_dst (const vector bool char *, int, const int);
+void vec_dst (const vector unsigned short *, int, const int);
+void vec_dst (const vector signed short *, int, const int);
+void vec_dst (const vector bool short *, int, const int);
+void vec_dst (const vector pixel *, int, const int);
+void vec_dst (const vector unsigned int *, int, const int);
+void vec_dst (const vector signed int *, int, const int);
+void vec_dst (const vector bool int *, int, const int);
+void vec_dst (const vector float *, int, const int);
+void vec_dst (const unsigned char *, int, const int);
+void vec_dst (const signed char *, int, const int);
+void vec_dst (const unsigned short *, int, const int);
+void vec_dst (const short *, int, const int);
+void vec_dst (const unsigned int *, int, const int);
+void vec_dst (const int *, int, const int);
+void vec_dst (const unsigned long *, int, const int);
+void vec_dst (const long *, int, const int);
+void vec_dst (const float *, int, const int);
+
+void vec_dstst (const vector unsigned char *, int, const int);
+void vec_dstst (const vector signed char *, int, const int);
+void vec_dstst (const vector bool char *, int, const int);
+void vec_dstst (const vector unsigned short *, int, const int);
+void vec_dstst (const vector signed short *, int, const int);
+void vec_dstst (const vector bool short *, int, const int);
+void vec_dstst (const vector pixel *, int, const int);
+void vec_dstst (const vector unsigned int *, int, const int);
+void vec_dstst (const vector signed int *, int, const int);
+void vec_dstst (const vector bool int *, int, const int);
+void vec_dstst (const vector float *, int, const int);
+void vec_dstst (const unsigned char *, int, const int);
+void vec_dstst (const signed char *, int, const int);
+void vec_dstst (const unsigned short *, int, const int);
+void vec_dstst (const short *, int, const int);
+void vec_dstst (const unsigned int *, int, const int);
+void vec_dstst (const int *, int, const int);
+void vec_dstst (const unsigned long *, int, const int);
+void vec_dstst (const long *, int, const int);
+void vec_dstst (const float *, int, const int);
+
+void vec_dststt (const vector unsigned char *, int, const int);
+void vec_dststt (const vector signed char *, int, const int);
+void vec_dststt (const vector bool char *, int, const int);
+void vec_dststt (const vector unsigned short *, int, const int);
+void vec_dststt (const vector signed short *, int, const int);
+void vec_dststt (const vector bool short *, int, const int);
+void vec_dststt (const vector pixel *, int, const int);
+void vec_dststt (const vector unsigned int *, int, const int);
+void vec_dststt (const vector signed int *, int, const int);
+void vec_dststt (const vector bool int *, int, const int);
+void vec_dststt (const vector float *, int, const int);
+void vec_dststt (const unsigned char *, int, const int);
+void vec_dststt (const signed char *, int, const int);
+void vec_dststt (const unsigned short *, int, const int);
+void vec_dststt (const short *, int, const int);
+void vec_dststt (const unsigned int *, int, const int);
+void vec_dststt (const int *, int, const int);
+void vec_dststt (const unsigned long *, int, const int);
+void vec_dststt (const long *, int, const int);
+void vec_dststt (const float *, int, const int);
+
+void vec_dstt (const vector unsigned char *, int, const int);
+void vec_dstt (const vector signed char *, int, const int);
+void vec_dstt (const vector bool char *, int, const int);
+void vec_dstt (const vector unsigned short *, int, const int);
+void vec_dstt (const vector signed short *, int, const int);
+void vec_dstt (const vector bool short *, int, const int);
+void vec_dstt (const vector pixel *, int, const int);
+void vec_dstt (const vector unsigned int *, int, const int);
+void vec_dstt (const vector signed int *, int, const int);
+void vec_dstt (const vector bool int *, int, const int);
+void vec_dstt (const vector float *, int, const int);
+void vec_dstt (const unsigned char *, int, const int);
+void vec_dstt (const signed char *, int, const int);
+void vec_dstt (const unsigned short *, int, const int);
+void vec_dstt (const short *, int, const int);
+void vec_dstt (const unsigned int *, int, const int);
+void vec_dstt (const int *, int, const int);
+void vec_dstt (const unsigned long *, int, const int);
+void vec_dstt (const long *, int, const int);
+void vec_dstt (const float *, int, const int);
+
+vector float vec_expte (vector float);
+
+vector float vec_floor (vector float);
+
+vector float vec_ld (int, const vector float *);
+vector float vec_ld (int, const float *);
+vector bool int vec_ld (int, const vector bool int *);
+vector signed int vec_ld (int, const vector signed int *);
+vector signed int vec_ld (int, const int *);
+vector signed int vec_ld (int, const long *);
+vector unsigned int vec_ld (int, const vector unsigned int *);
+vector unsigned int vec_ld (int, const unsigned int *);
+vector unsigned int vec_ld (int, const unsigned long *);
+vector bool short vec_ld (int, const vector bool short *);
+vector pixel vec_ld (int, const vector pixel *);
+vector signed short vec_ld (int, const vector signed short *);
+vector signed short vec_ld (int, const short *);
+vector unsigned short vec_ld (int, const vector unsigned short *);
+vector unsigned short vec_ld (int, const unsigned short *);
+vector bool char vec_ld (int, const vector bool char *);
+vector signed char vec_ld (int, const vector signed char *);
+vector signed char vec_ld (int, const signed char *);
+vector unsigned char vec_ld (int, const vector unsigned char *);
+vector unsigned char vec_ld (int, const unsigned char *);
+
+vector signed char vec_lde (int, const signed char *);
+vector unsigned char vec_lde (int, const unsigned char *);
+vector signed short vec_lde (int, const short *);
+vector unsigned short vec_lde (int, const unsigned short *);
+vector float vec_lde (int, const float *);
+vector signed int vec_lde (int, const int *);
+vector unsigned int vec_lde (int, const unsigned int *);
+vector signed int vec_lde (int, const long *);
+vector unsigned int vec_lde (int, const unsigned long *);
+
+vector float vec_lvewx (int, float *);
+vector signed int vec_lvewx (int, int *);
+vector unsigned int vec_lvewx (int, unsigned int *);
+vector signed int vec_lvewx (int, long *);
+vector unsigned int vec_lvewx (int, unsigned long *);
+
+vector signed short vec_lvehx (int, short *);
+vector unsigned short vec_lvehx (int, unsigned short *);
+
+vector signed char vec_lvebx (int, char *);
+vector unsigned char vec_lvebx (int, unsigned char *);
+
+vector float vec_ldl (int, const vector float *);
+vector float vec_ldl (int, const float *);
+vector bool int vec_ldl (int, const vector bool int *);
+vector signed int vec_ldl (int, const vector signed int *);
+vector signed int vec_ldl (int, const int *);
+vector signed int vec_ldl (int, const long *);
+vector unsigned int vec_ldl (int, const vector unsigned int *);
+vector unsigned int vec_ldl (int, const unsigned int *);
+vector unsigned int vec_ldl (int, const unsigned long *);
+vector bool short vec_ldl (int, const vector bool short *);
+vector pixel vec_ldl (int, const vector pixel *);
+vector signed short vec_ldl (int, const vector signed short *);
+vector signed short vec_ldl (int, const short *);
+vector unsigned short vec_ldl (int, const vector unsigned short *);
+vector unsigned short vec_ldl (int, const unsigned short *);
+vector bool char vec_ldl (int, const vector bool char *);
+vector signed char vec_ldl (int, const vector signed char *);
+vector signed char vec_ldl (int, const signed char *);
+vector unsigned char vec_ldl (int, const vector unsigned char *);
+vector unsigned char vec_ldl (int, const unsigned char *);
 
 vector float vec_loge (vector float);
 
-vector unsigned char vec_lvsl (int, void *, int *);
-
-vector unsigned char vec_lvsr (int, void *, int *);
+vector unsigned char vec_lvsl (int, const volatile unsigned char *);
+vector unsigned char vec_lvsl (int, const volatile signed char *);
+vector unsigned char vec_lvsl (int, const volatile unsigned short *);
+vector unsigned char vec_lvsl (int, const volatile short *);
+vector unsigned char vec_lvsl (int, const volatile unsigned int *);
+vector unsigned char vec_lvsl (int, const volatile int *);
+vector unsigned char vec_lvsl (int, const volatile unsigned long *);
+vector unsigned char vec_lvsl (int, const volatile long *);
+vector unsigned char vec_lvsl (int, const volatile float *);
+
+vector unsigned char vec_lvsr (int, const volatile unsigned char *);
+vector unsigned char vec_lvsr (int, const volatile signed char *);
+vector unsigned char vec_lvsr (int, const volatile unsigned short *);
+vector unsigned char vec_lvsr (int, const volatile short *);
+vector unsigned char vec_lvsr (int, const volatile unsigned int *);
+vector unsigned char vec_lvsr (int, const volatile int *);
+vector unsigned char vec_lvsr (int, const volatile unsigned long *);
+vector unsigned char vec_lvsr (int, const volatile long *);
+vector unsigned char vec_lvsr (int, const volatile float *);
 
 vector float vec_madd (vector float, vector float, vector float);
 
-vector signed short vec_madds (vector signed short, vector signed short,
+vector signed short vec_madds (vector signed short,
+                               vector signed short,
                                vector signed short);
 
-vector unsigned char vec_max (vector signed char, vector unsigned char);
-
-vector unsigned char vec_max (vector unsigned char, vector signed char);
-
+vector unsigned char vec_max (vector bool char, vector unsigned char);
+vector unsigned char vec_max (vector unsigned char, vector bool char);
 vector unsigned char vec_max (vector unsigned char,
                               vector unsigned char);
+vector signed char vec_max (vector bool char, vector signed char);
+vector signed char vec_max (vector signed char, vector bool char);
 vector signed char vec_max (vector signed char, vector signed char);
-vector unsigned short vec_max (vector signed short,
+vector unsigned short vec_max (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_max (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_max (vector unsigned short,
                                vector unsigned short);
+vector signed short vec_max (vector bool short, vector signed short);
+vector signed short vec_max (vector signed short, vector bool short);
 vector signed short vec_max (vector signed short, vector signed short);
-vector unsigned int vec_max (vector signed int, vector unsigned int);
-vector unsigned int vec_max (vector unsigned int, vector signed int);
+vector unsigned int vec_max (vector bool int, vector unsigned int);
+vector unsigned int vec_max (vector unsigned int, vector bool int);
 vector unsigned int vec_max (vector unsigned int, vector unsigned int);
+vector signed int vec_max (vector bool int, vector signed int);
+vector signed int vec_max (vector signed int, vector bool int);
 vector signed int vec_max (vector signed int, vector signed int);
 vector float vec_max (vector float, vector float);
 
+vector float vec_vmaxfp (vector float, vector float);
+
+vector signed int vec_vmaxsw (vector bool int, vector signed int);
+vector signed int vec_vmaxsw (vector signed int, vector bool int);
+vector signed int vec_vmaxsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vmaxuw (vector bool int, vector unsigned int);
+vector unsigned int vec_vmaxuw (vector unsigned int, vector bool int);
+vector unsigned int vec_vmaxuw (vector unsigned int,
+                                vector unsigned int);
+
+vector signed short vec_vmaxsh (vector bool short, vector signed short);
+vector signed short vec_vmaxsh (vector signed short, vector bool short);
+vector signed short vec_vmaxsh (vector signed short,
+                                vector signed short);
+
+vector unsigned short vec_vmaxuh (vector bool short,
+                                  vector unsigned short);
+vector unsigned short vec_vmaxuh (vector unsigned short,
+                                  vector bool short);
+vector unsigned short vec_vmaxuh (vector unsigned short,
+                                  vector unsigned short);
+
+vector signed char vec_vmaxsb (vector bool char, vector signed char);
+vector signed char vec_vmaxsb (vector signed char, vector bool char);
+vector signed char vec_vmaxsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vmaxub (vector bool char,
+                                 vector unsigned char);
+vector unsigned char vec_vmaxub (vector unsigned char,
+                                 vector bool char);
+vector unsigned char vec_vmaxub (vector unsigned char,
+                                 vector unsigned char);
+
+vector bool char vec_mergeh (vector bool char, vector bool char);
 vector signed char vec_mergeh (vector signed char, vector signed char);
 vector unsigned char vec_mergeh (vector unsigned char,
                                  vector unsigned char);
+vector bool short vec_mergeh (vector bool short, vector bool short);
+vector pixel vec_mergeh (vector pixel, vector pixel);
 vector signed short vec_mergeh (vector signed short,
                                 vector signed short);
 vector unsigned short vec_mergeh (vector unsigned short,
                                   vector unsigned short);
 vector float vec_mergeh (vector float, vector float);
+vector bool int vec_mergeh (vector bool int, vector bool int);
 vector signed int vec_mergeh (vector signed int, vector signed int);
 vector unsigned int vec_mergeh (vector unsigned int,
                                 vector unsigned int);
 
+vector float vec_vmrghw (vector float, vector float);
+vector bool int vec_vmrghw (vector bool int, vector bool int);
+vector signed int vec_vmrghw (vector signed int, vector signed int);
+vector unsigned int vec_vmrghw (vector unsigned int,
+                                vector unsigned int);
+
+vector bool short vec_vmrghh (vector bool short, vector bool short);
+vector signed short vec_vmrghh (vector signed short,
+                                vector signed short);
+vector unsigned short vec_vmrghh (vector unsigned short,
+                                  vector unsigned short);
+vector pixel vec_vmrghh (vector pixel, vector pixel);
+
+vector bool char vec_vmrghb (vector bool char, vector bool char);
+vector signed char vec_vmrghb (vector signed char, vector signed char);
+vector unsigned char vec_vmrghb (vector unsigned char,
+                                 vector unsigned char);
+
+vector bool char vec_mergel (vector bool char, vector bool char);
 vector signed char vec_mergel (vector signed char, vector signed char);
 vector unsigned char vec_mergel (vector unsigned char,
                                  vector unsigned char);
+vector bool short vec_mergel (vector bool short, vector bool short);
+vector pixel vec_mergel (vector pixel, vector pixel);
 vector signed short vec_mergel (vector signed short,
                                 vector signed short);
 vector unsigned short vec_mergel (vector unsigned short,
                                   vector unsigned short);
 vector float vec_mergel (vector float, vector float);
+vector bool int vec_mergel (vector bool int, vector bool int);
 vector signed int vec_mergel (vector signed int, vector signed int);
 vector unsigned int vec_mergel (vector unsigned int,
                                 vector unsigned int);
 
-vector unsigned short vec_mfvscr (void);
+vector float vec_vmrglw (vector float, vector float);
+vector signed int vec_vmrglw (vector signed int, vector signed int);
+vector unsigned int vec_vmrglw (vector unsigned int,
+                                vector unsigned int);
+vector bool int vec_vmrglw (vector bool int, vector bool int);
 
-vector unsigned char vec_min (vector signed char, vector unsigned char);
+vector bool short vec_vmrglh (vector bool short, vector bool short);
+vector signed short vec_vmrglh (vector signed short,
+                                vector signed short);
+vector unsigned short vec_vmrglh (vector unsigned short,
+                                  vector unsigned short);
+vector pixel vec_vmrglh (vector pixel, vector pixel);
+
+vector bool char vec_vmrglb (vector bool char, vector bool char);
+vector signed char vec_vmrglb (vector signed char, vector signed char);
+vector unsigned char vec_vmrglb (vector unsigned char,
+                                 vector unsigned char);
 
-vector unsigned char vec_min (vector unsigned char, vector signed char);
+vector unsigned short vec_mfvscr (void);
 
+vector unsigned char vec_min (vector bool char, vector unsigned char);
+vector unsigned char vec_min (vector unsigned char, vector bool char);
 vector unsigned char vec_min (vector unsigned char,
                               vector unsigned char);
+vector signed char vec_min (vector bool char, vector signed char);
+vector signed char vec_min (vector signed char, vector bool char);
 vector signed char vec_min (vector signed char, vector signed char);
-vector unsigned short vec_min (vector signed short,
+vector unsigned short vec_min (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_min (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_min (vector unsigned short,
                                vector unsigned short);
+vector signed short vec_min (vector bool short, vector signed short);
+vector signed short vec_min (vector signed short, vector bool short);
 vector signed short vec_min (vector signed short, vector signed short);
-vector unsigned int vec_min (vector signed int, vector unsigned int);
-vector unsigned int vec_min (vector unsigned int, vector signed int);
+vector unsigned int vec_min (vector bool int, vector unsigned int);
+vector unsigned int vec_min (vector unsigned int, vector bool int);
 vector unsigned int vec_min (vector unsigned int, vector unsigned int);
+vector signed int vec_min (vector bool int, vector signed int);
+vector signed int vec_min (vector signed int, vector bool int);
 vector signed int vec_min (vector signed int, vector signed int);
 vector float vec_min (vector float, vector float);
 
-vector signed short vec_mladd (vector signed short, vector signed short,
+vector float vec_vminfp (vector float, vector float);
+
+vector signed int vec_vminsw (vector bool int, vector signed int);
+vector signed int vec_vminsw (vector signed int, vector bool int);
+vector signed int vec_vminsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vminuw (vector bool int, vector unsigned int);
+vector unsigned int vec_vminuw (vector unsigned int, vector bool int);
+vector unsigned int vec_vminuw (vector unsigned int,
+                                vector unsigned int);
+
+vector signed short vec_vminsh (vector bool short, vector signed short);
+vector signed short vec_vminsh (vector signed short, vector bool short);
+vector signed short vec_vminsh (vector signed short,
+                                vector signed short);
+
+vector unsigned short vec_vminuh (vector bool short,
+                                  vector unsigned short);
+vector unsigned short vec_vminuh (vector unsigned short,
+                                  vector bool short);
+vector unsigned short vec_vminuh (vector unsigned short,
+                                  vector unsigned short);
+
+vector signed char vec_vminsb (vector bool char, vector signed char);
+vector signed char vec_vminsb (vector signed char, vector bool char);
+vector signed char vec_vminsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vminub (vector bool char,
+                                 vector unsigned char);
+vector unsigned char vec_vminub (vector unsigned char,
+                                 vector bool char);
+vector unsigned char vec_vminub (vector unsigned char,
+                                 vector unsigned char);
+
+vector signed short vec_mladd (vector signed short,
+                               vector signed short,
                                vector signed short);
 vector signed short vec_mladd (vector signed short,
                                vector unsigned short,
@@ -6463,34 +6874,78 @@ vector signed short vec_mradds (vector signed short,
 vector unsigned int vec_msum (vector unsigned char,
                               vector unsigned char,
                               vector unsigned int);
-vector signed int vec_msum (vector signed char, vector unsigned char,
+vector signed int vec_msum (vector signed char,
+                            vector unsigned char,
                             vector signed int);
 vector unsigned int vec_msum (vector unsigned short,
                               vector unsigned short,
                               vector unsigned int);
-vector signed int vec_msum (vector signed short, vector signed short,
+vector signed int vec_msum (vector signed short,
+                            vector signed short,
                             vector signed int);
 
+vector signed int vec_vmsumshm (vector signed short,
+                                vector signed short,
+                                vector signed int);
+
+vector unsigned int vec_vmsumuhm (vector unsigned short,
+                                  vector unsigned short,
+                                  vector unsigned int);
+
+vector signed int vec_vmsummbm (vector signed char,
+                                vector unsigned char,
+                                vector signed int);
+
+vector unsigned int vec_vmsumubm (vector unsigned char,
+                                  vector unsigned char,
+                                  vector unsigned int);
+
 vector unsigned int vec_msums (vector unsigned short,
                                vector unsigned short,
                                vector unsigned int);
-vector signed int vec_msums (vector signed short, vector signed short,
+vector signed int vec_msums (vector signed short,
+                             vector signed short,
                              vector signed int);
 
+vector signed int vec_vmsumshs (vector signed short,
+                                vector signed short,
+                                vector signed int);
+
+vector unsigned int vec_vmsumuhs (vector unsigned short,
+                                  vector unsigned short,
+                                  vector unsigned int);
+
 void vec_mtvscr (vector signed int);
 void vec_mtvscr (vector unsigned int);
+void vec_mtvscr (vector bool int);
 void vec_mtvscr (vector signed short);
 void vec_mtvscr (vector unsigned short);
+void vec_mtvscr (vector bool short);
+void vec_mtvscr (vector pixel);
 void vec_mtvscr (vector signed char);
 void vec_mtvscr (vector unsigned char);
+void vec_mtvscr (vector bool char);
 
 vector unsigned short vec_mule (vector unsigned char,
                                 vector unsigned char);
-vector signed short vec_mule (vector signed char, vector signed char);
+vector signed short vec_mule (vector signed char,
+                              vector signed char);
 vector unsigned int vec_mule (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_mule (vector signed short, vector signed short);
 
+vector signed int vec_vmulesh (vector signed short,
+                               vector signed short);
+
+vector unsigned int vec_vmuleuh (vector unsigned short,
+                                 vector unsigned short);
+
+vector signed short vec_vmulesb (vector signed char,
+                                 vector signed char);
+
+vector unsigned short vec_vmuleub (vector unsigned char,
+                                  vector unsigned char);
+
 vector unsigned short vec_mulo (vector unsigned char,
                                 vector unsigned char);
 vector signed short vec_mulo (vector signed char, vector signed char);
@@ -6498,56 +6953,100 @@ vector unsigned int vec_mulo (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_mulo (vector signed short, vector signed short);
 
+vector signed int vec_vmulosh (vector signed short,
+                               vector signed short);
+
+vector unsigned int vec_vmulouh (vector unsigned short,
+                                 vector unsigned short);
+
+vector signed short vec_vmulosb (vector signed char,
+                                 vector signed char);
+
+vector unsigned short vec_vmuloub (vector unsigned char,
+                                   vector unsigned char);
+
 vector float vec_nmsub (vector float, vector float, vector float);
 
 vector float vec_nor (vector float, vector float);
 vector signed int vec_nor (vector signed int, vector signed int);
 vector unsigned int vec_nor (vector unsigned int, vector unsigned int);
+vector bool int vec_nor (vector bool int, vector bool int);
 vector signed short vec_nor (vector signed short, vector signed short);
 vector unsigned short vec_nor (vector unsigned short,
                                vector unsigned short);
+vector bool short vec_nor (vector bool short, vector bool short);
 vector signed char vec_nor (vector signed char, vector signed char);
 vector unsigned char vec_nor (vector unsigned char,
                               vector unsigned char);
+vector bool char vec_nor (vector bool char, vector bool char);
 
 vector float vec_or (vector float, vector float);
-vector float vec_or (vector float, vector signed int);
-vector float vec_or (vector signed int, vector float);
+vector float vec_or (vector float, vector bool int);
+vector float vec_or (vector bool int, vector float);
+vector bool int vec_or (vector bool int, vector bool int);
+vector signed int vec_or (vector bool int, vector signed int);
+vector signed int vec_or (vector signed int, vector bool int);
 vector signed int vec_or (vector signed int, vector signed int);
-vector unsigned int vec_or (vector signed int, vector unsigned int);
-vector unsigned int vec_or (vector unsigned int, vector signed int);
+vector unsigned int vec_or (vector bool int, vector unsigned int);
+vector unsigned int vec_or (vector unsigned int, vector bool int);
 vector unsigned int vec_or (vector unsigned int, vector unsigned int);
+vector bool short vec_or (vector bool short, vector bool short);
+vector signed short vec_or (vector bool short, vector signed short);
+vector signed short vec_or (vector signed short, vector bool short);
 vector signed short vec_or (vector signed short, vector signed short);
-vector unsigned short vec_or (vector signed short,
-                              vector unsigned short);
-vector unsigned short vec_or (vector unsigned short,
-                              vector signed short);
+vector unsigned short vec_or (vector bool short, vector unsigned short);
+vector unsigned short vec_or (vector unsigned short, vector bool short);
 vector unsigned short vec_or (vector unsigned short,
                               vector unsigned short);
+vector signed char vec_or (vector bool char, vector signed char);
+vector bool char vec_or (vector bool char, vector bool char);
+vector signed char vec_or (vector signed char, vector bool char);
 vector signed char vec_or (vector signed char, vector signed char);
-vector unsigned char vec_or (vector signed char, vector unsigned char);
-vector unsigned char vec_or (vector unsigned char, vector signed char);
+vector unsigned char vec_or (vector bool char, vector unsigned char);
+vector unsigned char vec_or (vector unsigned char, vector bool char);
 vector unsigned char vec_or (vector unsigned char,
                              vector unsigned char);
 
 vector signed char vec_pack (vector signed short, vector signed short);
 vector unsigned char vec_pack (vector unsigned short,
                                vector unsigned short);
+vector bool char vec_pack (vector bool short, vector bool short);
 vector signed short vec_pack (vector signed int, vector signed int);
 vector unsigned short vec_pack (vector unsigned int,
                                 vector unsigned int);
+vector bool short vec_pack (vector bool int, vector bool int);
 
-vector signed short vec_packpx (vector unsigned int,
-                                vector unsigned int);
+vector bool short vec_vpkuwum (vector bool int, vector bool int);
+vector signed short vec_vpkuwum (vector signed int, vector signed int);
+vector unsigned short vec_vpkuwum (vector unsigned int,
+                                   vector unsigned int);
+
+vector bool char vec_vpkuhum (vector bool short, vector bool short);
+vector signed char vec_vpkuhum (vector signed short,
+                                vector signed short);
+vector unsigned char vec_vpkuhum (vector unsigned short,
+                                  vector unsigned short);
+
+vector pixel vec_packpx (vector unsigned int, vector unsigned int);
 
 vector unsigned char vec_packs (vector unsigned short,
                                 vector unsigned short);
 vector signed char vec_packs (vector signed short, vector signed short);
-
 vector unsigned short vec_packs (vector unsigned int,
                                  vector unsigned int);
 vector signed short vec_packs (vector signed int, vector signed int);
 
+vector signed short vec_vpkswss (vector signed int, vector signed int);
+
+vector unsigned short vec_vpkuwus (vector unsigned int,
+                                   vector unsigned int);
+
+vector signed char vec_vpkshss (vector signed short,
+                                vector signed short);
+
+vector unsigned char vec_vpkuhus (vector unsigned short,
+                                  vector unsigned short);
+
 vector unsigned char vec_packsu (vector unsigned short,
                                  vector unsigned short);
 vector unsigned char vec_packsu (vector signed short,
@@ -6556,114 +7055,221 @@ vector unsigned short vec_packsu (vector unsigned int,
                                   vector unsigned int);
 vector unsigned short vec_packsu (vector signed int, vector signed int);
 
-vector float vec_perm (vector float, vector float,
+vector unsigned short vec_vpkswus (vector signed int,
+                                   vector signed int);
+
+vector unsigned char vec_vpkshus (vector signed short,
+                                  vector signed short);
+
+vector float vec_perm (vector float,
+                       vector float,
                        vector unsigned char);
-vector signed int vec_perm (vector signed int, vector signed int,
+vector signed int vec_perm (vector signed int,
+                            vector signed int,
                             vector unsigned char);
-vector unsigned int vec_perm (vector unsigned int, vector unsigned int,
+vector unsigned int vec_perm (vector unsigned int,
+                              vector unsigned int,
                               vector unsigned char);
-vector signed short vec_perm (vector signed short, vector signed short,
+vector bool int vec_perm (vector bool int,
+                          vector bool int,
+                          vector unsigned char);
+vector signed short vec_perm (vector signed short,
+                              vector signed short,
                               vector unsigned char);
 vector unsigned short vec_perm (vector unsigned short,
                                 vector unsigned short,
                                 vector unsigned char);
-vector signed char vec_perm (vector signed char, vector signed char,
+vector bool short vec_perm (vector bool short,
+                            vector bool short,
+                            vector unsigned char);
+vector pixel vec_perm (vector pixel,
+                       vector pixel,
+                       vector unsigned char);
+vector signed char vec_perm (vector signed char,
+                             vector signed char,
                              vector unsigned char);
 vector unsigned char vec_perm (vector unsigned char,
                                vector unsigned char,
                                vector unsigned char);
+vector bool char vec_perm (vector bool char,
+                           vector bool char,
+                           vector unsigned char);
 
 vector float vec_re (vector float);
 
-vector signed char vec_rl (vector signed char, vector unsigned char);
+vector signed char vec_rl (vector signed char,
+                           vector unsigned char);
 vector unsigned char vec_rl (vector unsigned char,
                              vector unsigned char);
 vector signed short vec_rl (vector signed short, vector unsigned short);
-
 vector unsigned short vec_rl (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_rl (vector signed int, vector unsigned int);
 vector unsigned int vec_rl (vector unsigned int, vector unsigned int);
 
+vector signed int vec_vrlw (vector signed int, vector unsigned int);
+vector unsigned int vec_vrlw (vector unsigned int, vector unsigned int);
+
+vector signed short vec_vrlh (vector signed short,
+                              vector unsigned short);
+vector unsigned short vec_vrlh (vector unsigned short,
+                                vector unsigned short);
+
+vector signed char vec_vrlb (vector signed char, vector unsigned char);
+vector unsigned char vec_vrlb (vector unsigned char,
+                               vector unsigned char);
+
 vector float vec_round (vector float);
 
 vector float vec_rsqrte (vector float);
 
-vector float vec_sel (vector float, vector float, vector signed int);
+vector float vec_sel (vector float, vector float, vector bool int);
 vector float vec_sel (vector float, vector float, vector unsigned int);
-vector signed int vec_sel (vector signed int, vector signed int,
-                           vector signed int);
-vector signed int vec_sel (vector signed int, vector signed int,
+vector signed int vec_sel (vector signed int,
+                           vector signed int,
+                           vector bool int);
+vector signed int vec_sel (vector signed int,
+                           vector signed int,
                            vector unsigned int);
-vector unsigned int vec_sel (vector unsigned int, vector unsigned int,
-                             vector signed int);
-vector unsigned int vec_sel (vector unsigned int, vector unsigned int,
+vector unsigned int vec_sel (vector unsigned int,
+                             vector unsigned int,
+                             vector bool int);
+vector unsigned int vec_sel (vector unsigned int,
+                             vector unsigned int,
                              vector unsigned int);
-vector signed short vec_sel (vector signed short, vector signed short,
-                             vector signed short);
-vector signed short vec_sel (vector signed short, vector signed short,
+vector bool int vec_sel (vector bool int,
+                         vector bool int,
+                         vector bool int);
+vector bool int vec_sel (vector bool int,
+                         vector bool int,
+                         vector unsigned int);
+vector signed short vec_sel (vector signed short,
+                             vector signed short,
+                             vector bool short);
+vector signed short vec_sel (vector signed short,
+                             vector signed short,
                              vector unsigned short);
 vector unsigned short vec_sel (vector unsigned short,
                                vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_sel (vector unsigned short,
                                vector unsigned short,
                                vector unsigned short);
-vector signed char vec_sel (vector signed char, vector signed char,
-                            vector signed char);
-vector signed char vec_sel (vector signed char, vector signed char,
+vector bool short vec_sel (vector bool short,
+                           vector bool short,
+                           vector bool short);
+vector bool short vec_sel (vector bool short,
+                           vector bool short,
+                           vector unsigned short);
+vector signed char vec_sel (vector signed char,
+                            vector signed char,
+                            vector bool char);
+vector signed char vec_sel (vector signed char,
+                            vector signed char,
                             vector unsigned char);
 vector unsigned char vec_sel (vector unsigned char,
                               vector unsigned char,
-                              vector signed char);
+                              vector bool char);
 vector unsigned char vec_sel (vector unsigned char,
                               vector unsigned char,
                               vector unsigned char);
-
-vector signed char vec_sl (vector signed char, vector unsigned char);
+vector bool char vec_sel (vector bool char,
+                          vector bool char,
+                          vector bool char);
+vector bool char vec_sel (vector bool char,
+                          vector bool char,
+                          vector unsigned char);
+
+vector signed char vec_sl (vector signed char,
+                           vector unsigned char);
 vector unsigned char vec_sl (vector unsigned char,
                              vector unsigned char);
 vector signed short vec_sl (vector signed short, vector unsigned short);
-
 vector unsigned short vec_sl (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_sl (vector signed int, vector unsigned int);
 vector unsigned int vec_sl (vector unsigned int, vector unsigned int);
 
-vector float vec_sld (vector float, vector float, const char);
-vector signed int vec_sld (vector signed int, vector signed int,
-                           const char);
-vector unsigned int vec_sld (vector unsigned int, vector unsigned int,
-                             const char);
-vector signed short vec_sld (vector signed short, vector signed short,
-                             const char);
+vector signed int vec_vslw (vector signed int, vector unsigned int);
+vector unsigned int vec_vslw (vector unsigned int, vector unsigned int);
+
+vector signed short vec_vslh (vector signed short,
+                              vector unsigned short);
+vector unsigned short vec_vslh (vector unsigned short,
+                                vector unsigned short);
+
+vector signed char vec_vslb (vector signed char, vector unsigned char);
+vector unsigned char vec_vslb (vector unsigned char,
+                               vector unsigned char);
+
+vector float vec_sld (vector float, vector float, const int);
+vector signed int vec_sld (vector signed int,
+                           vector signed int,
+                           const int);
+vector unsigned int vec_sld (vector unsigned int,
+                             vector unsigned int,
+                             const int);
+vector bool int vec_sld (vector bool int,
+                         vector bool int,
+                         const int);
+vector signed short vec_sld (vector signed short,
+                             vector signed short,
+                             const int);
 vector unsigned short vec_sld (vector unsigned short,
-                               vector unsigned short, const char);
-vector signed char vec_sld (vector signed char, vector signed char,
-                            const char);
+                               vector unsigned short,
+                               const int);
+vector bool short vec_sld (vector bool short,
+                           vector bool short,
+                           const int);
+vector pixel vec_sld (vector pixel,
+                      vector pixel,
+                      const int);
+vector signed char vec_sld (vector signed char,
+                            vector signed char,
+                            const int);
 vector unsigned char vec_sld (vector unsigned char,
                               vector unsigned char,
-                              const char);
+                              const int);
+vector bool char vec_sld (vector bool char,
+                          vector bool char,
+                          const int);
 
-vector signed int vec_sll (vector signed int, vector unsigned int);
-vector signed int vec_sll (vector signed int, vector unsigned short);
-vector signed int vec_sll (vector signed int, vector unsigned char);
-vector unsigned int vec_sll (vector unsigned int, vector unsigned int);
+vector signed int vec_sll (vector signed int,
+                           vector unsigned int);
+vector signed int vec_sll (vector signed int,
+                           vector unsigned short);
+vector signed int vec_sll (vector signed int,
+                           vector unsigned char);
+vector unsigned int vec_sll (vector unsigned int,
+                             vector unsigned int);
 vector unsigned int vec_sll (vector unsigned int,
                              vector unsigned short);
-vector unsigned int vec_sll (vector unsigned int, vector unsigned char);
-
-vector signed short vec_sll (vector signed short, vector unsigned int);
+vector unsigned int vec_sll (vector unsigned int,
+                             vector unsigned char);
+vector bool int vec_sll (vector bool int,
+                         vector unsigned int);
+vector bool int vec_sll (vector bool int,
+                         vector unsigned short);
+vector bool int vec_sll (vector bool int,
+                         vector unsigned char);
+vector signed short vec_sll (vector signed short,
+                             vector unsigned int);
 vector signed short vec_sll (vector signed short,
                              vector unsigned short);
-vector signed short vec_sll (vector signed short, vector unsigned char);
-
+vector signed short vec_sll (vector signed short,
+                             vector unsigned char);
 vector unsigned short vec_sll (vector unsigned short,
                                vector unsigned int);
 vector unsigned short vec_sll (vector unsigned short,
                                vector unsigned short);
 vector unsigned short vec_sll (vector unsigned short,
                                vector unsigned char);
+vector bool short vec_sll (vector bool short, vector unsigned int);
+vector bool short vec_sll (vector bool short, vector unsigned short);
+vector bool short vec_sll (vector bool short, vector unsigned char);
+vector pixel vec_sll (vector pixel, vector unsigned int);
+vector pixel vec_sll (vector pixel, vector unsigned short);
+vector pixel vec_sll (vector pixel, vector unsigned char);
 vector signed char vec_sll (vector signed char, vector unsigned int);
 vector signed char vec_sll (vector signed char, vector unsigned short);
 vector signed char vec_sll (vector signed char, vector unsigned char);
@@ -6673,6 +7279,9 @@ vector unsigned char vec_sll (vector unsigned char,
                               vector unsigned short);
 vector unsigned char vec_sll (vector unsigned char,
                               vector unsigned char);
+vector bool char vec_sll (vector bool char, vector unsigned int);
+vector bool char vec_sll (vector bool char, vector unsigned short);
+vector bool char vec_sll (vector bool char, vector unsigned char);
 
 vector float vec_slo (vector float, vector signed char);
 vector float vec_slo (vector float, vector unsigned char);
@@ -6680,51 +7289,80 @@ vector signed int vec_slo (vector signed int, vector signed char);
 vector signed int vec_slo (vector signed int, vector unsigned char);
 vector unsigned int vec_slo (vector unsigned int, vector signed char);
 vector unsigned int vec_slo (vector unsigned int, vector unsigned char);
-
 vector signed short vec_slo (vector signed short, vector signed char);
 vector signed short vec_slo (vector signed short, vector unsigned char);
-
 vector unsigned short vec_slo (vector unsigned short,
                                vector signed char);
 vector unsigned short vec_slo (vector unsigned short,
                                vector unsigned char);
+vector pixel vec_slo (vector pixel, vector signed char);
+vector pixel vec_slo (vector pixel, vector unsigned char);
 vector signed char vec_slo (vector signed char, vector signed char);
 vector signed char vec_slo (vector signed char, vector unsigned char);
 vector unsigned char vec_slo (vector unsigned char, vector signed char);
-
 vector unsigned char vec_slo (vector unsigned char,
                               vector unsigned char);
 
-vector signed char vec_splat (vector signed char, const char);
-vector unsigned char vec_splat (vector unsigned char, const char);
-vector signed short vec_splat (vector signed short, const char);
-vector unsigned short vec_splat (vector unsigned short, const char);
-vector float vec_splat (vector float, const char);
-vector signed int vec_splat (vector signed int, const char);
-vector unsigned int vec_splat (vector unsigned int, const char);
+vector signed char vec_splat (vector signed char, const int);
+vector unsigned char vec_splat (vector unsigned char, const int);
+vector bool char vec_splat (vector bool char, const int);
+vector signed short vec_splat (vector signed short, const int);
+vector unsigned short vec_splat (vector unsigned short, const int);
+vector bool short vec_splat (vector bool short, const int);
+vector pixel vec_splat (vector pixel, const int);
+vector float vec_splat (vector float, const int);
+vector signed int vec_splat (vector signed int, const int);
+vector unsigned int vec_splat (vector unsigned int, const int);
+vector bool int vec_splat (vector bool int, const int);
+
+vector float vec_vspltw (vector float, const int);
+vector signed int vec_vspltw (vector signed int, const int);
+vector unsigned int vec_vspltw (vector unsigned int, const int);
+vector bool int vec_vspltw (vector bool int, const int);
 
-vector signed char vec_splat_s8 (const char);
+vector bool short vec_vsplth (vector bool short, const int);
+vector signed short vec_vsplth (vector signed short, const int);
+vector unsigned short vec_vsplth (vector unsigned short, const int);
+vector pixel vec_vsplth (vector pixel, const int);
 
-vector signed short vec_splat_s16 (const char);
+vector signed char vec_vspltb (vector signed char, const int);
+vector unsigned char vec_vspltb (vector unsigned char, const int);
+vector bool char vec_vspltb (vector bool char, const int);
 
-vector signed int vec_splat_s32 (const char);
+vector signed char vec_splat_s8 (const int);
 
-vector unsigned char vec_splat_u8 (const char);
+vector signed short vec_splat_s16 (const int);
 
-vector unsigned short vec_splat_u16 (const char);
+vector signed int vec_splat_s32 (const int);
 
-vector unsigned int vec_splat_u32 (const char);
+vector unsigned char vec_splat_u8 (const int);
+
+vector unsigned short vec_splat_u16 (const int);
+
+vector unsigned int vec_splat_u32 (const int);
 
 vector signed char vec_sr (vector signed char, vector unsigned char);
 vector unsigned char vec_sr (vector unsigned char,
                              vector unsigned char);
-vector signed short vec_sr (vector signed short, vector unsigned short);
-
+vector signed short vec_sr (vector signed short,
+                            vector unsigned short);
 vector unsigned short vec_sr (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_sr (vector signed int, vector unsigned int);
 vector unsigned int vec_sr (vector unsigned int, vector unsigned int);
 
+vector signed int vec_vsrw (vector signed int, vector unsigned int);
+vector unsigned int vec_vsrw (vector unsigned int, vector unsigned int);
+
+vector signed short vec_vsrh (vector signed short,
+                              vector unsigned short);
+vector unsigned short vec_vsrh (vector unsigned short,
+                                vector unsigned short);
+
+vector signed char vec_vsrb (vector signed char, vector unsigned char);
+vector unsigned char vec_vsrb (vector unsigned char,
+                               vector unsigned char);
+
 vector signed char vec_sra (vector signed char, vector unsigned char);
 vector unsigned char vec_sra (vector unsigned char,
                               vector unsigned char);
@@ -6735,6 +7373,19 @@ vector unsigned short vec_sra (vector unsigned short,
 vector signed int vec_sra (vector signed int, vector unsigned int);
 vector unsigned int vec_sra (vector unsigned int, vector unsigned int);
 
+vector signed int vec_vsraw (vector signed int, vector unsigned int);
+vector unsigned int vec_vsraw (vector unsigned int,
+                               vector unsigned int);
+
+vector signed short vec_vsrah (vector signed short,
+                               vector unsigned short);
+vector unsigned short vec_vsrah (vector unsigned short,
+                                 vector unsigned short);
+
+vector signed char vec_vsrab (vector signed char, vector unsigned char);
+vector unsigned char vec_vsrab (vector unsigned char,
+                                vector unsigned char);
+
 vector signed int vec_srl (vector signed int, vector unsigned int);
 vector signed int vec_srl (vector signed int, vector unsigned short);
 vector signed int vec_srl (vector signed int, vector unsigned char);
@@ -6742,18 +7393,25 @@ vector unsigned int vec_srl (vector unsigned int, vector unsigned int);
 vector unsigned int vec_srl (vector unsigned int,
                              vector unsigned short);
 vector unsigned int vec_srl (vector unsigned int, vector unsigned char);
-
+vector bool int vec_srl (vector bool int, vector unsigned int);
+vector bool int vec_srl (vector bool int, vector unsigned short);
+vector bool int vec_srl (vector bool int, vector unsigned char);
 vector signed short vec_srl (vector signed short, vector unsigned int);
 vector signed short vec_srl (vector signed short,
                              vector unsigned short);
 vector signed short vec_srl (vector signed short, vector unsigned char);
-
 vector unsigned short vec_srl (vector unsigned short,
                                vector unsigned int);
 vector unsigned short vec_srl (vector unsigned short,
                                vector unsigned short);
 vector unsigned short vec_srl (vector unsigned short,
                                vector unsigned char);
+vector bool short vec_srl (vector bool short, vector unsigned int);
+vector bool short vec_srl (vector bool short, vector unsigned short);
+vector bool short vec_srl (vector bool short, vector unsigned char);
+vector pixel vec_srl (vector pixel, vector unsigned int);
+vector pixel vec_srl (vector pixel, vector unsigned short);
+vector pixel vec_srl (vector pixel, vector unsigned char);
 vector signed char vec_srl (vector signed char, vector unsigned int);
 vector signed char vec_srl (vector signed char, vector unsigned short);
 vector signed char vec_srl (vector signed char, vector unsigned char);
@@ -6763,6 +7421,9 @@ vector unsigned char vec_srl (vector unsigned char,
                               vector unsigned short);
 vector unsigned char vec_srl (vector unsigned char,
                               vector unsigned char);
+vector bool char vec_srl (vector bool char, vector unsigned int);
+vector bool char vec_srl (vector bool char, vector unsigned short);
+vector bool char vec_srl (vector bool char, vector unsigned char);
 
 vector float vec_sro (vector float, vector signed char);
 vector float vec_sro (vector float, vector unsigned char);
@@ -6770,115 +7431,236 @@ vector signed int vec_sro (vector signed int, vector signed char);
 vector signed int vec_sro (vector signed int, vector unsigned char);
 vector unsigned int vec_sro (vector unsigned int, vector signed char);
 vector unsigned int vec_sro (vector unsigned int, vector unsigned char);
-
 vector signed short vec_sro (vector signed short, vector signed char);
 vector signed short vec_sro (vector signed short, vector unsigned char);
-
 vector unsigned short vec_sro (vector unsigned short,
                                vector signed char);
 vector unsigned short vec_sro (vector unsigned short,
                                vector unsigned char);
+vector pixel vec_sro (vector pixel, vector signed char);
+vector pixel vec_sro (vector pixel, vector unsigned char);
 vector signed char vec_sro (vector signed char, vector signed char);
 vector signed char vec_sro (vector signed char, vector unsigned char);
 vector unsigned char vec_sro (vector unsigned char, vector signed char);
-
 vector unsigned char vec_sro (vector unsigned char,
                               vector unsigned char);
 
-void vec_st (vector float, int, float *);
 void vec_st (vector float, int, vector float *);
+void vec_st (vector float, int, float *);
+void vec_st (vector signed int, int, vector signed int *);
 void vec_st (vector signed int, int, int *);
-void vec_st (vector signed int, int, unsigned int *);
-void vec_st (vector unsigned int, int, unsigned int *);
 void vec_st (vector unsigned int, int, vector unsigned int *);
-void vec_st (vector signed short, int, short *);
-void vec_st (vector signed short, int, vector unsigned short *);
+void vec_st (vector unsigned int, int, unsigned int *);
+void vec_st (vector bool int, int, vector bool int *);
+void vec_st (vector bool int, int, unsigned int *);
+void vec_st (vector bool int, int, int *);
 void vec_st (vector signed short, int, vector signed short *);
-void vec_st (vector unsigned short, int, unsigned short *);
+void vec_st (vector signed short, int, short *);
 void vec_st (vector unsigned short, int, vector unsigned short *);
-void vec_st (vector signed char, int, signed char *);
-void vec_st (vector signed char, int, unsigned char *);
+void vec_st (vector unsigned short, int, unsigned short *);
+void vec_st (vector bool short, int, vector bool short *);
+void vec_st (vector bool short, int, unsigned short *);
+void vec_st (vector pixel, int, vector pixel *);
+void vec_st (vector pixel, int, unsigned short *);
+void vec_st (vector pixel, int, short *);
+void vec_st (vector bool short, int, short *);
 void vec_st (vector signed char, int, vector signed char *);
-void vec_st (vector unsigned char, int, unsigned char *);
+void vec_st (vector signed char, int, signed char *);
 void vec_st (vector unsigned char, int, vector unsigned char *);
+void vec_st (vector unsigned char, int, unsigned char *);
+void vec_st (vector bool char, int, vector bool char *);
+void vec_st (vector bool char, int, unsigned char *);
+void vec_st (vector bool char, int, signed char *);
 
-void vec_ste (vector signed char, int, unsigned char *);
 void vec_ste (vector signed char, int, signed char *);
 void vec_ste (vector unsigned char, int, unsigned char *);
+void vec_ste (vector bool char, int, signed char *);
+void vec_ste (vector bool char, int, unsigned char *);
 void vec_ste (vector signed short, int, short *);
-void vec_ste (vector signed short, int, unsigned short *);
-void vec_ste (vector unsigned short, int, void *);
-void vec_ste (vector signed int, int, unsigned int *);
+void vec_ste (vector unsigned short, int, unsigned short *);
+void vec_ste (vector bool short, int, short *);
+void vec_ste (vector bool short, int, unsigned short *);
+void vec_ste (vector pixel, int, short *);
+void vec_ste (vector pixel, int, unsigned short *);
+void vec_ste (vector float, int, float *);
 void vec_ste (vector signed int, int, int *);
 void vec_ste (vector unsigned int, int, unsigned int *);
-void vec_ste (vector float, int, float *);
+void vec_ste (vector bool int, int, int *);
+void vec_ste (vector bool int, int, unsigned int *);
+
+void vec_stvewx (vector float, int, float *);
+void vec_stvewx (vector signed int, int, int *);
+void vec_stvewx (vector unsigned int, int, unsigned int *);
+void vec_stvewx (vector bool int, int, int *);
+void vec_stvewx (vector bool int, int, unsigned int *);
+
+void vec_stvehx (vector signed short, int, short *);
+void vec_stvehx (vector unsigned short, int, unsigned short *);
+void vec_stvehx (vector bool short, int, short *);
+void vec_stvehx (vector bool short, int, unsigned short *);
+void vec_stvehx (vector pixel, int, short *);
+void vec_stvehx (vector pixel, int, unsigned short *);
+
+void vec_stvebx (vector signed char, int, signed char *);
+void vec_stvebx (vector unsigned char, int, unsigned char *);
+void vec_stvebx (vector bool char, int, signed char *);
+void vec_stvebx (vector bool char, int, unsigned char *);
 
 void vec_stl (vector float, int, vector float *);
 void vec_stl (vector float, int, float *);
 void vec_stl (vector signed int, int, vector signed int *);
 void vec_stl (vector signed int, int, int *);
-void vec_stl (vector signed int, int, unsigned int *);
 void vec_stl (vector unsigned int, int, vector unsigned int *);
 void vec_stl (vector unsigned int, int, unsigned int *);
-void vec_stl (vector signed short, int, short *);
-void vec_stl (vector signed short, int, unsigned short *);
+void vec_stl (vector bool int, int, vector bool int *);
+void vec_stl (vector bool int, int, unsigned int *);
+void vec_stl (vector bool int, int, int *);
 void vec_stl (vector signed short, int, vector signed short *);
+void vec_stl (vector signed short, int, short *);
+void vec_stl (vector unsigned short, int, vector unsigned short *);
 void vec_stl (vector unsigned short, int, unsigned short *);
-void vec_stl (vector unsigned short, int, vector signed short *);
-void vec_stl (vector signed char, int, signed char *);
-void vec_stl (vector signed char, int, unsigned char *);
+void vec_stl (vector bool short, int, vector bool short *);
+void vec_stl (vector bool short, int, unsigned short *);
+void vec_stl (vector bool short, int, short *);
+void vec_stl (vector pixel, int, vector pixel *);
+void vec_stl (vector pixel, int, unsigned short *);
+void vec_stl (vector pixel, int, short *);
 void vec_stl (vector signed char, int, vector signed char *);
-void vec_stl (vector unsigned char, int, unsigned char *);
+void vec_stl (vector signed char, int, signed char *);
 void vec_stl (vector unsigned char, int, vector unsigned char *);
+void vec_stl (vector unsigned char, int, unsigned char *);
+void vec_stl (vector bool char, int, vector bool char *);
+void vec_stl (vector bool char, int, unsigned char *);
+void vec_stl (vector bool char, int, signed char *);
 
+vector signed char vec_sub (vector bool char, vector signed char);
+vector signed char vec_sub (vector signed char, vector bool char);
 vector signed char vec_sub (vector signed char, vector signed char);
-vector unsigned char vec_sub (vector signed char, vector unsigned char);
-
-vector unsigned char vec_sub (vector unsigned char, vector signed char);
-
+vector unsigned char vec_sub (vector bool char, vector unsigned char);
+vector unsigned char vec_sub (vector unsigned char, vector bool char);
 vector unsigned char vec_sub (vector unsigned char,
                               vector unsigned char);
+vector signed short vec_sub (vector bool short, vector signed short);
+vector signed short vec_sub (vector signed short, vector bool short);
 vector signed short vec_sub (vector signed short, vector signed short);
-vector unsigned short vec_sub (vector signed short,
+vector unsigned short vec_sub (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_sub (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_sub (vector unsigned short,
                                vector unsigned short);
+vector signed int vec_sub (vector bool int, vector signed int);
+vector signed int vec_sub (vector signed int, vector bool int);
 vector signed int vec_sub (vector signed int, vector signed int);
-vector unsigned int vec_sub (vector signed int, vector unsigned int);
-vector unsigned int vec_sub (vector unsigned int, vector signed int);
+vector unsigned int vec_sub (vector bool int, vector unsigned int);
+vector unsigned int vec_sub (vector unsigned int, vector bool int);
 vector unsigned int vec_sub (vector unsigned int, vector unsigned int);
 vector float vec_sub (vector float, vector float);
 
+vector float vec_vsubfp (vector float, vector float);
+
+vector signed int vec_vsubuwm (vector bool int, vector signed int);
+vector signed int vec_vsubuwm (vector signed int, vector bool int);
+vector signed int vec_vsubuwm (vector signed int, vector signed int);
+vector unsigned int vec_vsubuwm (vector bool int, vector unsigned int);
+vector unsigned int vec_vsubuwm (vector unsigned int, vector bool int);
+vector unsigned int vec_vsubuwm (vector unsigned int,
+                                 vector unsigned int);
+
+vector signed short vec_vsubuhm (vector bool short,
+                                 vector signed short);
+vector signed short vec_vsubuhm (vector signed short,
+                                 vector bool short);
+vector signed short vec_vsubuhm (vector signed short,
+                                 vector signed short);
+vector unsigned short vec_vsubuhm (vector bool short,
+                                   vector unsigned short);
+vector unsigned short vec_vsubuhm (vector unsigned short,
+                                   vector bool short);
+vector unsigned short vec_vsubuhm (vector unsigned short,
+                                   vector unsigned short);
+
+vector signed char vec_vsububm (vector bool char, vector signed char);
+vector signed char vec_vsububm (vector signed char, vector bool char);
+vector signed char vec_vsububm (vector signed char, vector signed char);
+vector unsigned char vec_vsububm (vector bool char,
+                                  vector unsigned char);
+vector unsigned char vec_vsububm (vector unsigned char,
+                                  vector bool char);
+vector unsigned char vec_vsububm (vector unsigned char,
+                                  vector unsigned char);
+
 vector unsigned int vec_subc (vector unsigned int, vector unsigned int);
 
-vector unsigned char vec_subs (vector signed char,
-                               vector unsigned char);
-vector unsigned char vec_subs (vector unsigned char,
-                               vector signed char);
+vector unsigned char vec_subs (vector bool char, vector unsigned char);
+vector unsigned char vec_subs (vector unsigned char, vector bool char);
 vector unsigned char vec_subs (vector unsigned char,
                                vector unsigned char);
+vector signed char vec_subs (vector bool char, vector signed char);
+vector signed char vec_subs (vector signed char, vector bool char);
 vector signed char vec_subs (vector signed char, vector signed char);
-vector unsigned short vec_subs (vector signed short,
+vector unsigned short vec_subs (vector bool short,
                                 vector unsigned short);
 vector unsigned short vec_subs (vector unsigned short,
-                                vector signed short);
+                                vector bool short);
 vector unsigned short vec_subs (vector unsigned short,
                                 vector unsigned short);
+vector signed short vec_subs (vector bool short, vector signed short);
+vector signed short vec_subs (vector signed short, vector bool short);
 vector signed short vec_subs (vector signed short, vector signed short);
-
-vector unsigned int vec_subs (vector signed int, vector unsigned int);
-vector unsigned int vec_subs (vector unsigned int, vector signed int);
+vector unsigned int vec_subs (vector bool int, vector unsigned int);
+vector unsigned int vec_subs (vector unsigned int, vector bool int);
 vector unsigned int vec_subs (vector unsigned int, vector unsigned int);
-
+vector signed int vec_subs (vector bool int, vector signed int);
+vector signed int vec_subs (vector signed int, vector bool int);
 vector signed int vec_subs (vector signed int, vector signed int);
 
+vector signed int vec_vsubsws (vector bool int, vector signed int);
+vector signed int vec_vsubsws (vector signed int, vector bool int);
+vector signed int vec_vsubsws (vector signed int, vector signed int);
+
+vector unsigned int vec_vsubuws (vector bool int, vector unsigned int);
+vector unsigned int vec_vsubuws (vector unsigned int, vector bool int);
+vector unsigned int vec_vsubuws (vector unsigned int,
+                                 vector unsigned int);
+
+vector signed short vec_vsubshs (vector bool short,
+                                 vector signed short);
+vector signed short vec_vsubshs (vector signed short,
+                                 vector bool short);
+vector signed short vec_vsubshs (vector signed short,
+                                 vector signed short);
+
+vector unsigned short vec_vsubuhs (vector bool short,
+                                   vector unsigned short);
+vector unsigned short vec_vsubuhs (vector unsigned short,
+                                   vector bool short);
+vector unsigned short vec_vsubuhs (vector unsigned short,
+                                   vector unsigned short);
+
+vector signed char vec_vsubsbs (vector bool char, vector signed char);
+vector signed char vec_vsubsbs (vector signed char, vector bool char);
+vector signed char vec_vsubsbs (vector signed char, vector signed char);
+
+vector unsigned char vec_vsububs (vector bool char,
+                                  vector unsigned char);
+vector unsigned char vec_vsububs (vector unsigned char,
+                                  vector bool char);
+vector unsigned char vec_vsububs (vector unsigned char,
+                                  vector unsigned char);
+
 vector unsigned int vec_sum4s (vector unsigned char,
                                vector unsigned int);
 vector signed int vec_sum4s (vector signed char, vector signed int);
 vector signed int vec_sum4s (vector signed short, vector signed int);
 
+vector signed int vec_vsum4shs (vector signed short, vector signed int);
+
+vector signed int vec_vsum4sbs (vector signed char, vector signed int);
+
+vector unsigned int vec_vsum4ubs (vector unsigned char,
+                                  vector unsigned int);
+
 vector signed int vec_sum2s (vector signed int, vector signed int);
 
 vector signed int vec_sums (vector signed int, vector signed int);
@@ -6886,326 +7668,345 @@ vector signed int vec_sums (vector signed int, vector signed int);
 vector float vec_trunc (vector float);
 
 vector signed short vec_unpackh (vector signed char);
-vector unsigned int vec_unpackh (vector signed short);
+vector bool short vec_unpackh (vector bool char);
 vector signed int vec_unpackh (vector signed short);
+vector bool int vec_unpackh (vector bool short);
+vector unsigned int vec_unpackh (vector pixel);
+
+vector bool int vec_vupkhsh (vector bool short);
+vector signed int vec_vupkhsh (vector signed short);
+
+vector unsigned int vec_vupkhpx (vector pixel);
+
+vector bool short vec_vupkhsb (vector bool char);
+vector signed short vec_vupkhsb (vector signed char);
 
 vector signed short vec_unpackl (vector signed char);
-vector unsigned int vec_unpackl (vector signed short);
+vector bool short vec_unpackl (vector bool char);
+vector unsigned int vec_unpackl (vector pixel);
 vector signed int vec_unpackl (vector signed short);
+vector bool int vec_unpackl (vector bool short);
+
+vector unsigned int vec_vupklpx (vector pixel);
+
+vector bool int vec_vupklsh (vector bool short);
+vector signed int vec_vupklsh (vector signed short);
+
+vector bool short vec_vupklsb (vector bool char);
+vector signed short vec_vupklsb (vector signed char);
 
 vector float vec_xor (vector float, vector float);
-vector float vec_xor (vector float, vector signed int);
-vector float vec_xor (vector signed int, vector float);
+vector float vec_xor (vector float, vector bool int);
+vector float vec_xor (vector bool int, vector float);
+vector bool int vec_xor (vector bool int, vector bool int);
+vector signed int vec_xor (vector bool int, vector signed int);
+vector signed int vec_xor (vector signed int, vector bool int);
 vector signed int vec_xor (vector signed int, vector signed int);
-vector unsigned int vec_xor (vector signed int, vector unsigned int);
-vector unsigned int vec_xor (vector unsigned int, vector signed int);
+vector unsigned int vec_xor (vector bool int, vector unsigned int);
+vector unsigned int vec_xor (vector unsigned int, vector bool int);
 vector unsigned int vec_xor (vector unsigned int, vector unsigned int);
+vector bool short vec_xor (vector bool short, vector bool short);
+vector signed short vec_xor (vector bool short, vector signed short);
+vector signed short vec_xor (vector signed short, vector bool short);
 vector signed short vec_xor (vector signed short, vector signed short);
-vector unsigned short vec_xor (vector signed short,
+vector unsigned short vec_xor (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_xor (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_xor (vector unsigned short,
                                vector unsigned short);
+vector signed char vec_xor (vector bool char, vector signed char);
+vector bool char vec_xor (vector bool char, vector bool char);
+vector signed char vec_xor (vector signed char, vector bool char);
 vector signed char vec_xor (vector signed char, vector signed char);
-vector unsigned char vec_xor (vector signed char, vector unsigned char);
-
-vector unsigned char vec_xor (vector unsigned char, vector signed char);
-
+vector unsigned char vec_xor (vector bool char, vector unsigned char);
+vector unsigned char vec_xor (vector unsigned char, vector bool char);
 vector unsigned char vec_xor (vector unsigned char,
                               vector unsigned char);
 
-vector signed int vec_all_eq (vector signed char, vector unsigned char);
-
-vector signed int vec_all_eq (vector signed char, vector signed char);
-vector signed int vec_all_eq (vector unsigned char, vector signed char);
-
-vector signed int vec_all_eq (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_all_eq (vector signed short,
-               &nbs