gcc-4.6.0: Bring in patches from FSF 4.6 branch

This brings in new patches from 4.6 release branch
updates the comment section of existing branch to not
contain patch numbers.

Tested build on qemu for arm ppc mips x86 and x86_64

Signed-off-by: Khem Raj <raj.khem@gmail.com>

1 files changed, 460 insertions, 0 deletions

diff --git a/meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0281-PR-c-48869.patch b/meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0281-PR-c-48869.patch
new file mode 100644
index 000000000..a3b18bf0f
--- /dev/null
+++ b/meta/recipes-devtools/gcc/gcc-4.6.0/gcc-4_6-branch-backports/0281-PR-c-48869.patch
@@ -0,0 +1,460 @@
+From 727aac5bae5c8b9e10e7b4ff1756cc722dd9ef2f Mon Sep 17 00:00:00 2001
+From: jakub <jakub@138bc75d-0d04-0410-961f-82ee72b054a4>
+Date: Thu, 19 May 2011 08:00:50 +0000
+Subject: [PATCH] 	PR c++/48869
+ 	* method.c (get_dtor, get_copy_ctor): Add COMPLAIN argument,
+ 	pass it down to locate_fn_flags.
+ 	* cp-tree.h (get_dtor, get_copy_ctor): Adjust prototypes.
+ 	* semantics.c (cxx_omp_create_clause_info): Adjust callers.
+ 	* cp-gimplify.c: Include splay-tree.h.
+ 	(splay_tree_compare_decl_uid, omp_var_to_track,
+ 	omp_cxx_notice_variable): New functions.
+ 	(struct cp_genericize_omp_taskreg): New type.
+ 	(struct cp_genericize_data): Add omp_ctx field.
+ 	(cp_genericize_r): Attempt to determine implicitly determined
+ 	firstprivate class type variables.
+ 	(cp_genericize): Clear omp_ctx.
+ 	* Make-lang.in (cp/cp-gimplify.o): Depend on $(SPLAY_TREE_H).
+
+	* testsuite/libgomp.c++/pr48869.C: New test.
+
+
+git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gcc-4_6-branch@173889 138bc75d-0d04-0410-961f-82ee72b054a4
+
+index 3734714..d0a9e58 100644
+--- a/gcc/cp/Make-lang.in
++++ b/gcc/cp/Make-lang.in
+@@ -1,6 +1,6 @@
+ # Top level -*- makefile -*- fragment for GNU C++.
+ #   Copyright (C) 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+-#   2005, 2007, 2008, 2009, 2010
++#   2005, 2007, 2008, 2009, 2010, 2011
+ #   Free Software Foundation, Inc.
+ 
+ #This file is part of GCC.
+@@ -318,7 +318,7 @@ cp/parser.o: cp/parser.c $(CXX_TREE_H) $(TM_H) $(DIAGNOSTIC_CORE_H) \
+   gt-cp-parser.h output.h $(TARGET_H) $(PLUGIN_H) intl.h \
+   c-family/c-objc.h
+ cp/cp-gimplify.o: cp/cp-gimplify.c $(CXX_TREE_H) $(C_COMMON_H) \
+-	$(TM_H) coretypes.h pointer-set.h tree-iterator.h
++	$(TM_H) coretypes.h pointer-set.h tree-iterator.h $(SPLAY_TREE_H)
+ 
+ cp/name-lookup.o: cp/name-lookup.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
+ 	$(TM_H) $(CXX_TREE_H) $(TIMEVAR_H) gt-cp-name-lookup.h \
+diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
+index ca62df3..d26c0e0 100644
+--- a/gcc/cp/cp-gimplify.c
++++ b/gcc/cp/cp-gimplify.c
+@@ -1,6 +1,6 @@
+ /* C++-specific tree lowering bits; see also c-gimplify.c and tree-gimple.c.
+ 
+-   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
++   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+    Free Software Foundation, Inc.
+    Contributed by Jason Merrill <jason@redhat.com>
+ 
+@@ -32,6 +32,7 @@ along with GCC; see the file COPYING3.  If not see
+ #include "hashtab.h"
+ #include "pointer-set.h"
+ #include "flags.h"
++#include "splay-tree.h"
+ 
+ /* Local declarations.  */
+ 
+@@ -731,10 +732,105 @@ cxx_int_tree_map_hash (const void *item)
+   return ((const struct cxx_int_tree_map *)item)->uid;
+ }
+ 
++/* A stable comparison routine for use with splay trees and DECLs.  */
++
++static int
++splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
++{
++  tree a = (tree) xa;
++  tree b = (tree) xb;
++
++  return DECL_UID (a) - DECL_UID (b);
++}
++
++/* OpenMP context during genericization.  */
++
++struct cp_genericize_omp_taskreg
++{
++  bool is_parallel;
++  bool default_shared;
++  struct cp_genericize_omp_taskreg *outer;
++  splay_tree variables;
++};
++
++/* Return true if genericization should try to determine if
++   DECL is firstprivate or shared within task regions.  */
++
++static bool
++omp_var_to_track (tree decl)
++{
++  tree type = TREE_TYPE (decl);
++  if (is_invisiref_parm (decl))
++    type = TREE_TYPE (type);
++  while (TREE_CODE (type) == ARRAY_TYPE)
++    type = TREE_TYPE (type);
++  if (type == error_mark_node || !CLASS_TYPE_P (type))
++    return false;
++  if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
++    return false;
++  if (cxx_omp_predetermined_sharing (decl) != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
++    return false;
++  return true;
++}
++
++/* Note DECL use in OpenMP region OMP_CTX during genericization.  */
++
++static void
++omp_cxx_notice_variable (struct cp_genericize_omp_taskreg *omp_ctx, tree decl)
++{
++  splay_tree_node n = splay_tree_lookup (omp_ctx->variables,
++					 (splay_tree_key) decl);
++  if (n == NULL)
++    {
++      int flags = OMP_CLAUSE_DEFAULT_SHARED;
++      if (omp_ctx->outer)
++	omp_cxx_notice_variable (omp_ctx->outer, decl);
++      if (!omp_ctx->default_shared)
++	{
++	  struct cp_genericize_omp_taskreg *octx;
++
++	  for (octx = omp_ctx->outer; octx; octx = octx->outer)
++	    {
++	      n = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
++	      if (n && n->value != OMP_CLAUSE_DEFAULT_SHARED)
++		{
++		  flags = OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
++		  break;
++		}
++	      if (octx->is_parallel)
++		break;
++	    }
++	  if (octx == NULL
++	      && (TREE_CODE (decl) == PARM_DECL
++		  || (!(TREE_STATIC (decl) || DECL_EXTERNAL (decl))
++		      && DECL_CONTEXT (decl) == current_function_decl)))
++	    flags = OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
++	  if (flags == OMP_CLAUSE_DEFAULT_FIRSTPRIVATE)
++	    {
++	      /* DECL is implicitly determined firstprivate in
++		 the current task construct.  Ensure copy ctor and
++		 dtor are instantiated, because during gimplification
++		 it will be already too late.  */
++	      tree type = TREE_TYPE (decl);
++	      if (is_invisiref_parm (decl))
++		type = TREE_TYPE (type);
++	      while (TREE_CODE (type) == ARRAY_TYPE)
++		type = TREE_TYPE (type);
++	      get_copy_ctor (type, tf_none);
++	      get_dtor (type, tf_none);
++	    }
++	}
++      splay_tree_insert (omp_ctx->variables, (splay_tree_key) decl, flags);
++    }
++}
++
++/* Genericization context.  */
++
+ struct cp_genericize_data
+ {
+   struct pointer_set_t *p_set;
+   VEC (tree, heap) *bind_expr_stack;
++  struct cp_genericize_omp_taskreg *omp_ctx;
+ };
+ 
+ /* Perform any pre-gimplification lowering of C++ front end trees to
+@@ -747,6 +843,14 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
+   struct cp_genericize_data *wtd = (struct cp_genericize_data *) data;
+   struct pointer_set_t *p_set = wtd->p_set;
+ 
++  /* If in an OpenMP context, note var uses.  */
++  if (__builtin_expect (wtd->omp_ctx != NULL, 0)
++      && (TREE_CODE (stmt) == VAR_DECL
++	  || TREE_CODE (stmt) == PARM_DECL
++	  || TREE_CODE (stmt) == RESULT_DECL)
++      && omp_var_to_track (stmt))
++    omp_cxx_notice_variable (wtd->omp_ctx, stmt);
++
+   if (is_invisiref_parm (stmt)
+       /* Don't dereference parms in a thunk, pass the references through. */
+       && !(DECL_THUNK_P (current_function_decl)
+@@ -786,6 +890,10 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
+   if (TREE_CODE (stmt) == ADDR_EXPR
+       && is_invisiref_parm (TREE_OPERAND (stmt, 0)))
+     {
++      /* If in an OpenMP context, note var uses.  */
++      if (__builtin_expect (wtd->omp_ctx != NULL, 0)
++	  && omp_var_to_track (TREE_OPERAND (stmt, 0)))
++	omp_cxx_notice_variable (wtd->omp_ctx, TREE_OPERAND (stmt, 0));
+       *stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
+       *walk_subtrees = 0;
+     }
+@@ -808,6 +916,22 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
+ 	  }
+ 	break;
+       case OMP_CLAUSE_PRIVATE:
++	/* Don't dereference an invisiref in OpenMP clauses.  */
++	if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
++	  *walk_subtrees = 0;
++	else if (wtd->omp_ctx != NULL)
++	  {
++	    /* Private clause doesn't cause any references to the
++	       var in outer contexts, avoid calling
++	       omp_cxx_notice_variable for it.  */
++	    struct cp_genericize_omp_taskreg *old = wtd->omp_ctx;
++	    wtd->omp_ctx = NULL;
++	    cp_walk_tree (&OMP_CLAUSE_DECL (stmt), cp_genericize_r,
++			  data, NULL);
++	    wtd->omp_ctx = old;
++	    *walk_subtrees = 0;
++	  }
++	break;
+       case OMP_CLAUSE_SHARED:
+       case OMP_CLAUSE_FIRSTPRIVATE:
+       case OMP_CLAUSE_COPYIN:
+@@ -876,6 +1000,25 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
+ 
+   else if (TREE_CODE (stmt) == BIND_EXPR)
+     {
++      if (__builtin_expect (wtd->omp_ctx != NULL, 0))
++	{
++	  tree decl;
++	  for (decl = BIND_EXPR_VARS (stmt); decl; decl = DECL_CHAIN (decl))
++	    if (TREE_CODE (decl) == VAR_DECL
++		&& !DECL_EXTERNAL (decl)
++		&& omp_var_to_track (decl))
++	      {
++		splay_tree_node n
++		  = splay_tree_lookup (wtd->omp_ctx->variables,
++				       (splay_tree_key) decl);
++		if (n == NULL)
++		  splay_tree_insert (wtd->omp_ctx->variables,
++				     (splay_tree_key) decl,
++				     TREE_STATIC (decl)
++				     ? OMP_CLAUSE_DEFAULT_SHARED
++				     : OMP_CLAUSE_DEFAULT_PRIVATE);
++	      }
++	}
+       VEC_safe_push (tree, heap, wtd->bind_expr_stack, stmt);
+       cp_walk_tree (&BIND_EXPR_BODY (stmt),
+ 		    cp_genericize_r, data, NULL);
+@@ -922,6 +1065,50 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
+       *stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
+       *walk_subtrees = 0;
+     }
++  else if (TREE_CODE (stmt) == OMP_PARALLEL || TREE_CODE (stmt) == OMP_TASK)
++    {
++      struct cp_genericize_omp_taskreg omp_ctx;
++      tree c, decl;
++      splay_tree_node n;
++
++      *walk_subtrees = 0;
++      cp_walk_tree (&OMP_CLAUSES (stmt), cp_genericize_r, data, NULL);
++      omp_ctx.is_parallel = TREE_CODE (stmt) == OMP_PARALLEL;
++      omp_ctx.default_shared = omp_ctx.is_parallel;
++      omp_ctx.outer = wtd->omp_ctx;
++      omp_ctx.variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
++      wtd->omp_ctx = &omp_ctx;
++      for (c = OMP_CLAUSES (stmt); c; c = OMP_CLAUSE_CHAIN (c))
++	switch (OMP_CLAUSE_CODE (c))
++	  {
++	  case OMP_CLAUSE_SHARED:
++	  case OMP_CLAUSE_PRIVATE:
++	  case OMP_CLAUSE_FIRSTPRIVATE:
++	  case OMP_CLAUSE_LASTPRIVATE:
++	    decl = OMP_CLAUSE_DECL (c);
++	    if (decl == error_mark_node || !omp_var_to_track (decl))
++	      break;
++	    n = splay_tree_lookup (omp_ctx.variables, (splay_tree_key) decl);
++	    if (n != NULL)
++	      break;
++	    splay_tree_insert (omp_ctx.variables, (splay_tree_key) decl,
++			       OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
++			       ? OMP_CLAUSE_DEFAULT_SHARED
++			       : OMP_CLAUSE_DEFAULT_PRIVATE);
++	    if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_PRIVATE
++		&& omp_ctx.outer)
++	      omp_cxx_notice_variable (omp_ctx.outer, decl);
++	    break;
++	  case OMP_CLAUSE_DEFAULT:
++	    if (OMP_CLAUSE_DEFAULT_KIND (c) == OMP_CLAUSE_DEFAULT_SHARED)
++	      omp_ctx.default_shared = true;
++	  default:
++	    break;
++	  }
++      cp_walk_tree (&OMP_BODY (stmt), cp_genericize_r, data, NULL);
++      wtd->omp_ctx = omp_ctx.outer;
++      splay_tree_delete (omp_ctx.variables);
++    }
+ 
+   pointer_set_insert (p_set, *stmt_p);
+ 
+@@ -985,6 +1172,7 @@ cp_genericize (tree fndecl)
+      walk_tree's hash functionality.  */
+   wtd.p_set = pointer_set_create ();
+   wtd.bind_expr_stack = NULL;
++  wtd.omp_ctx = NULL;
+   cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, &wtd, NULL);
+   pointer_set_destroy (wtd.p_set);
+   VEC_free (tree, heap, wtd.bind_expr_stack);
+diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
+index be61dad..c7ca180 100644
+--- a/gcc/cp/cp-tree.h
++++ b/gcc/cp/cp-tree.h
+@@ -5003,10 +5003,10 @@ extern tree lazily_declare_fn			(special_function_kind,
+ extern tree skip_artificial_parms_for		(const_tree, tree);
+ extern int num_artificial_parms_for		(const_tree);
+ extern tree make_alias_for			(tree, tree);
+-extern tree get_copy_ctor			(tree);
++extern tree get_copy_ctor			(tree, tsubst_flags_t);
+ extern tree get_copy_assign			(tree);
+ extern tree get_default_ctor			(tree);
+-extern tree get_dtor				(tree);
++extern tree get_dtor				(tree, tsubst_flags_t);
+ extern tree locate_ctor				(tree);
+ 
+ /* In optimize.c */
+diff --git a/gcc/cp/method.c b/gcc/cp/method.c
+index e6f3c25..a693222 100644
+--- a/gcc/cp/method.c
++++ b/gcc/cp/method.c
+@@ -1,7 +1,7 @@
+ /* Handle the hair of processing (but not expanding) inline functions.
+    Also manage function and variable name overloading.
+    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+-   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
++   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
+    Free Software Foundation, Inc.
+    Contributed by Michael Tiemann (tiemann@cygnus.com)
+ 
+@@ -838,10 +838,10 @@ locate_fn_flags (tree type, tree name, tree argtype, int flags,
+ /* Locate the dtor of TYPE.  */
+ 
+ tree
+-get_dtor (tree type)
++get_dtor (tree type, tsubst_flags_t complain)
+ {
+   tree fn = locate_fn_flags (type, complete_dtor_identifier, NULL_TREE,
+-			     LOOKUP_NORMAL, tf_warning_or_error);
++			     LOOKUP_NORMAL, complain);
+   if (fn == error_mark_node)
+     return NULL_TREE;
+   return fn;
+@@ -878,13 +878,13 @@ get_default_ctor (tree type)
+ /* Locate the copy ctor of TYPE.  */
+ 
+ tree
+-get_copy_ctor (tree type)
++get_copy_ctor (tree type, tsubst_flags_t complain)
+ {
+   int quals = (TYPE_HAS_CONST_COPY_CTOR (type)
+ 	       ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
+   tree argtype = build_stub_type (type, quals, false);
+   tree fn = locate_fn_flags (type, complete_ctor_identifier, argtype,
+-			     LOOKUP_NORMAL, tf_warning_or_error);
++			     LOOKUP_NORMAL, complain);
+   if (fn == error_mark_node)
+     return NULL_TREE;
+   return fn;
+diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
+index 6b7ec39..48b37cf 100644
+--- a/gcc/cp/semantics.c
++++ b/gcc/cp/semantics.c
+@@ -3667,7 +3667,7 @@ cxx_omp_create_clause_info (tree c, tree type, bool need_default_ctor,
+       if (need_default_ctor)
+ 	t = get_default_ctor (type);
+       else
+-	t = get_copy_ctor (type);
++	t = get_copy_ctor (type, tf_warning_or_error);
+ 
+       if (t && !trivial_fn_p (t))
+ 	TREE_VEC_ELT (info, 0) = t;
+@@ -3675,7 +3675,7 @@ cxx_omp_create_clause_info (tree c, tree type, bool need_default_ctor,
+ 
+   if ((need_default_ctor || need_copy_ctor)
+       && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
+-    TREE_VEC_ELT (info, 1) = get_dtor (type);
++    TREE_VEC_ELT (info, 1) = get_dtor (type, tf_warning_or_error);
+ 
+   if (need_copy_assignment)
+     {
+new file mode 100644
+index 0000000..ec952d9
+--- /dev/null
++++ b/libgomp/testsuite/libgomp.c++/pr48869.C
+@@ -0,0 +1,68 @@
++// PR c++/48869
++// { dg-do run }
++// { dg-options "-std=gnu++0x" }
++
++template <const int N>
++struct A
++{
++  A () {}
++  A (const A&) = delete;
++  void foo () {}
++  ~A () {}
++};
++
++template <const int N>
++struct B
++{
++  B () {}
++  B (const B&) {}
++  void foo () {}
++  ~B () {}
++};
++
++void __attribute__((used))
++foo (B<6> b6)
++{
++  #pragma omp task
++    b6.foo ();
++}
++
++int
++main ()
++{
++  A<0> a0;
++  #pragma omp task shared(a0)
++    a0.foo ();
++  #pragma omp task default(shared)
++    a0.foo ();
++  #pragma omp parallel shared(a0)
++    #pragma omp task
++      a0.foo ();
++  #pragma omp task
++  {
++    A<1> a1;
++    a1.foo ();
++  }
++  B<0> b0;
++  #pragma omp task shared(b0)
++    b0.foo ();
++  B<1> b1;
++  #pragma omp task default(shared)
++    b1.foo ();
++  B<2> b2;
++  #pragma omp parallel shared(b2)
++    #pragma omp task
++      b2.foo ();
++  B<3> b3;
++  #pragma omp task
++    b3.foo ();
++  B<4> b4;
++  #pragma omp parallel private (b4)
++    #pragma omp task
++      b4.foo ();
++  B<5> b5;
++  #pragma omp parallel firstprivate (b5)
++    #pragma omp task
++      b5.foo ();
++  return 0;
++}
+-- 
+1.7.0.4
+