This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] Fix PR47615


This fixes an inconsistency exposed by my earlier fix for PRE.  The
fix is to just globally avoid the struct-copy look-through for PRE.

Bootstrapped and tested on x86_64-unknown-linux-gnu, applied to trunk.

Richard.

2011-02-07  Richard Guenther  <rguenther@suse.de>

	PR tree-optimization/47615
	* tree-ssa-sccvn.h (run_scc_vn): Take a vn-walk mode argument.
	* tree-ssa-sccvn.c (default_vn_walk_kind): New global.
	(run_scc_vn): Initialize it.
	(visit_reference_op_load): Use it.
	* tree-ssa-pre.c (execute_pre): Use VN_WALK if in PRE.

	* g++.dg/opt/pr47615.C: New testcase.

Index: gcc/tree-ssa-sccvn.h
===================================================================
*** gcc/tree-ssa-sccvn.h	(revision 169884)
--- gcc/tree-ssa-sccvn.h	(working copy)
*************** typedef struct vn_ssa_aux
*** 165,175 ****
    unsigned needs_insertion : 1;
  } *vn_ssa_aux_t;
  
  /* Return the value numbering info for an SSA_NAME.  */
  extern vn_ssa_aux_t VN_INFO (tree);
  extern vn_ssa_aux_t VN_INFO_GET (tree);
  tree vn_get_expr_for (tree);
! bool run_scc_vn (void);
  void free_scc_vn (void);
  tree vn_nary_op_lookup (tree, vn_nary_op_t *);
  tree vn_nary_op_lookup_stmt (gimple, vn_nary_op_t *);
--- 165,177 ----
    unsigned needs_insertion : 1;
  } *vn_ssa_aux_t;
  
+ typedef enum { VN_NOWALK, VN_WALK, VN_WALKREWRITE } vn_lookup_kind;
+ 
  /* Return the value numbering info for an SSA_NAME.  */
  extern vn_ssa_aux_t VN_INFO (tree);
  extern vn_ssa_aux_t VN_INFO_GET (tree);
  tree vn_get_expr_for (tree);
! bool run_scc_vn (vn_lookup_kind);
  void free_scc_vn (void);
  tree vn_nary_op_lookup (tree, vn_nary_op_t *);
  tree vn_nary_op_lookup_stmt (gimple, vn_nary_op_t *);
*************** void copy_reference_ops_from_ref (tree,
*** 187,193 ****
  void copy_reference_ops_from_call (gimple, VEC(vn_reference_op_s, heap) **);
  bool ao_ref_init_from_vn_reference (ao_ref *, alias_set_type, tree,
  				    VEC (vn_reference_op_s, heap) *);
- typedef enum { VN_NOWALK, VN_WALK, VN_WALKREWRITE } vn_lookup_kind;
  tree vn_reference_lookup_pieces (tree, alias_set_type, tree,
  				 VEC (vn_reference_op_s, heap) *,
  				 vn_reference_t *, vn_lookup_kind);
--- 189,194 ----
Index: gcc/tree-ssa-sccvn.c
===================================================================
*** gcc/tree-ssa-sccvn.c	(revision 169884)
--- gcc/tree-ssa-sccvn.c	(working copy)
*************** vn_reference_lookup_1 (vn_reference_t vr
*** 1244,1249 ****
--- 1244,1250 ----
  
  static tree *last_vuse_ptr;
  static vn_lookup_kind vn_walk_kind;
+ static vn_lookup_kind default_vn_walk_kind;
  
  /* Callback for walk_non_aliased_vuses.  Adjusts the vn_reference_t VR_
     with the current VUSE and performs the expression lookup.  */
*************** visit_reference_op_load (tree lhs, tree
*** 2261,2274 ****
  
    last_vuse = gimple_vuse (stmt);
    last_vuse_ptr = &last_vuse;
!   result = vn_reference_lookup (op, gimple_vuse (stmt), VN_WALKREWRITE, NULL);
    last_vuse_ptr = NULL;
  
    /* If we have a VCE, try looking up its operand as it might be stored in
       a different type.  */
    if (!result && TREE_CODE (op) == VIEW_CONVERT_EXPR)
      result = vn_reference_lookup (TREE_OPERAND (op, 0), gimple_vuse (stmt),
!     				  VN_WALKREWRITE, NULL);
  
    /* We handle type-punning through unions by value-numbering based
       on offset and size of the access.  Be prepared to handle a
--- 2262,2276 ----
  
    last_vuse = gimple_vuse (stmt);
    last_vuse_ptr = &last_vuse;
!   result = vn_reference_lookup (op, gimple_vuse (stmt),
! 				default_vn_walk_kind, NULL);
    last_vuse_ptr = NULL;
  
    /* If we have a VCE, try looking up its operand as it might be stored in
       a different type.  */
    if (!result && TREE_CODE (op) == VIEW_CONVERT_EXPR)
      result = vn_reference_lookup (TREE_OPERAND (op, 0), gimple_vuse (stmt),
!     				  default_vn_walk_kind, NULL);
  
    /* We handle type-punning through unions by value-numbering based
       on offset and size of the access.  Be prepared to handle a
*************** set_hashtable_value_ids (void)
*** 3463,3477 ****
  }
  
  /* Do SCCVN.  Returns true if it finished, false if we bailed out
!    due to resource constraints.  */
  
  bool
! run_scc_vn (void)
  {
    size_t i;
    tree param;
    bool changed = true;
  
    init_scc_vn ();
    current_info = valid_info;
  
--- 3465,3482 ----
  }
  
  /* Do SCCVN.  Returns true if it finished, false if we bailed out
!    due to resource constraints.  DEFAULT_VN_WALK_KIND_ specifies
!    how we use the alias oracle walking during the VN process.  */
  
  bool
! run_scc_vn (vn_lookup_kind default_vn_walk_kind_)
  {
    size_t i;
    tree param;
    bool changed = true;
  
+   default_vn_walk_kind = default_vn_walk_kind_;
+ 
    init_scc_vn ();
    current_info = valid_info;
  
Index: gcc/tree-ssa-pre.c
===================================================================
*** gcc/tree-ssa-pre.c	(revision 169884)
--- gcc/tree-ssa-pre.c	(working copy)
*************** execute_pre (bool do_fre)
*** 4853,4859 ****
    if (!do_fre)
      loop_optimizer_init (LOOPS_NORMAL);
  
!   if (!run_scc_vn ())
      {
        if (!do_fre)
  	loop_optimizer_finalize ();
--- 4864,4870 ----
    if (!do_fre)
      loop_optimizer_init (LOOPS_NORMAL);
  
!   if (!run_scc_vn (do_fre ? VN_WALKREWRITE : VN_WALK))
      {
        if (!do_fre)
  	loop_optimizer_finalize ();
Index: gcc/testsuite/g++.dg/opt/pr47615.C
===================================================================
*** gcc/testsuite/g++.dg/opt/pr47615.C	(revision 0)
--- gcc/testsuite/g++.dg/opt/pr47615.C	(revision 0)
***************
*** 0 ****
--- 1,711 ----
+ // { dg-do compile }
+ // { dg-options "-O -fstrict-aliasing -ftree-pre -fno-tree-fre -fno-tree-sra" }
+ 
+ typedef __SIZE_TYPE__ size_t;
+ namespace std 
+ {
+   template < class _T1, class > struct pair
+   {
+     _T1 first;
+   };
+ }
+ namespace __gnu_cxx
+ {
+   template < typename _Tp > class new_allocator
+   {
+   public:
+     typedef size_t size_type;
+     typedef _Tp * pointer;
+     typedef _Tp const_pointer;
+     typedef _Tp & reference;
+     typedef const _Tp & const_reference;
+     template < typename _Tp1 > struct rebind
+     {
+       typedef new_allocator < _Tp1 > other;
+     };
+   };
+ }
+ namespace std
+ {
+ template < typename _Tp > class allocator:
+   public __gnu_cxx::new_allocator < _Tp >
+   {};
+   template < typename, typename, typename > struct binary_function;
+   template < typename _Tp > struct less:binary_function < _Tp, _Tp, bool >
+   {};
+ }
+ namespace __gnu_cxx
+ {
+   namespace typelist
+   {
+     struct null_type;
+     template < typename Root > struct node
+     {
+       typedef Root root;
+     };
+     template < typename, typename > struct chain;
+     namespace detail
+     {
+       template < typename, int >struct chain_at_index_;
+       template
+ 	<
+ 	typename
+ 	Hd, typename Tl > struct chain_at_index_ <chain < Hd, Tl >, 0 >
+       {
+ 	typedef Hd type;
+       };
+       template
+ 	<
+ 	typename
+ 	Hd, typename Tl, int i > struct chain_at_index_ <chain < Hd, Tl >, i >
+       {
+ 	typedef typename chain_at_index_ < Tl, i - 1 >::type type;
+       };
+     }
+     template < typename Typelist, int i > struct at_index
+     {
+       typedef typename Typelist::root root_type;
+       typedef detail::chain_at_index_ < root_type, i > index_type;
+       typedef typename index_type::type type;
+     };
+     template < typename T1, typename T2 > struct create2
+     {
+       typedef node < chain < T1, chain < T2, null_type > > >type;
+     };
+   }
+ }
+ namespace std
+ {
+   namespace tr1
+   {
+     template < typename _Tp, _Tp __v > struct integral_constant
+     {
+       static const _Tp value = __v;
+     };
+     typedef integral_constant < bool, false > false_type;
+     template < typename, typename > struct is_same:false_type
+     {};
+   }
+ }
+ using std::tr1::is_same;
+ namespace __gnu_pbds
+ {
+   struct null_mapped_type;
+   struct rb_tree_tag;
+   namespace detail
+   {
+     template < typename, typename, typename > struct basic_tree_policy_base;
+     template
+       <
+       typename
+       Const_Node_Iterator,
+       typename
+       Allocator
+       >
+       struct
+       basic_tree_policy_base
+       <Const_Node_Iterator, Const_Node_Iterator, Allocator >
+     {};
+   }
+   template
+     < typename, typename, typename, typename > struct null_tree_node_update;
+ template < typename Const_Node_Iterator, typename Node_Iterator, typename, typename Allocator > class tree_order_statistics_node_update:
+   detail::basic_tree_policy_base
+     < Const_Node_Iterator, Node_Iterator, Allocator >
+   {
+   public:
+     typedef Allocator allocator_type;
+     typedef typename allocator_type::size_type size_type;
+     typedef size_type metadata_type;
+     typedef Const_Node_Iterator const_node_iterator;
+     typedef Node_Iterator node_iterator;
+     typedef
+       typename
+       allocator_type::template
+       rebind < metadata_type >::other::reference metadata_reference;
+     void operator () (node_iterator, const_node_iterator) const;
+   };
+   template
+     <
+     typename
+     Const_Node_Iterator,
+     class
+     Node_Iterator,
+     class
+     Cmp_Fn,
+     class
+     Allocator
+     >
+     inline
+     void
+     tree_order_statistics_node_update
+     <
+     Const_Node_Iterator,
+     Node_Iterator,
+     Cmp_Fn,
+     Allocator
+     >::operator
+     () (node_iterator node_it, const_node_iterator end_nd_it) const
+   {
+     node_iterator l_child_it;
+     size_type
+       l_rank = (l_child_it == end_nd_it) ? : l_child_it.get_metadata ();
+     node_iterator r_child_it = node_it.get_r_child ();
+     size_type
+       r_rank = (r_child_it == end_nd_it) ? : r_child_it.get_metadata ();
+     const_cast
+       < metadata_reference > (node_it.get_metadata ()) = l_rank + r_rank;
+   }
+   namespace
+   {
+     template < typename, typename, typename, bool > struct value_type_base;
+     template
+       <
+       typename
+       Key,
+       typename
+       Allocator
+       > struct value_type_base <Key, null_mapped_type, Allocator, false >
+     {
+       typedef Key value_type;
+       typedef
+ 	typename
+ 	Allocator::template rebind < value_type >::other value_type_allocator;
+       typedef typename value_type_allocator::pointer pointer;
+       typedef typename value_type_allocator::const_pointer const_pointer;
+       typedef typename value_type_allocator::reference reference;
+       typedef typename value_type_allocator::const_reference const_reference;
+     };
+     template
+       <
+       typename
+       Key,
+       typename
+       Mapped, typename Alloc, bool Store_Extra > struct vt_base_selector
+     {
+       typedef value_type_base < Key, Mapped, Alloc, Store_Extra > type;
+     };
+     template
+       <
+       typename
+       Key,
+       typename
+       Mapped,
+       typename
+       Alloc,
+       bool
+       Store_Extra
+       >
+       struct
+       types_traits:vt_base_selector < Key, Mapped, Alloc, Store_Extra >::type
+     {};
+     template < typename, class, class > struct dumconst_node_iterator;
+     template
+       <
+       typename
+       Key,
+       typename
+       Mapped,
+       class,
+       class
+       Node_And_It_Traits, class Allocator > class bin_search_tree_no_data_
+     {
+     protected:
+       typedef
+ 	typename
+ 	Allocator::template
+ 	rebind
+ 	< typename Node_And_It_Traits::node >::other::pointer node_pointer;
+       typedef
+ 	typename
+ 	types_traits
+ 	< Key, Mapped, Allocator, false >::const_reference const_reference;
+       typedef typename Node_And_It_Traits::point_iterator point_iterator;
+       typedef typename Node_And_It_Traits::node_update node_update;
+       void rotate_right (node_pointer);
+       template
+ 	<
+ 	typename
+ 	Node_Update_ > void apply_update (node_pointer, Node_Update_ *);
+     };
+     template
+       <
+       typename
+       Key,
+       typename
+       Mapped,
+       class
+       Cmp_Fn,
+       class
+       Node_And_It_Traits,
+       class
+       Allocator
+       >
+       void
+       bin_search_tree_no_data_
+       <
+       Key,
+       Mapped,
+       Cmp_Fn, Node_And_It_Traits, Allocator >::rotate_right (node_pointer p_x)
+     {
+       node_pointer p_y = p_x->m_p_parent;
+       p_y->m_p_right = p_x;
+       apply_update (p_x, this);
+       apply_update (p_x->m_p_parent, (node_update *) this);
+     }
+     template
+       <
+       typename
+       Key,
+       typename
+       Mapped,
+       class
+       Cmp_Fn,
+       class
+       Node_And_It_Traits,
+       class
+       Allocator
+       >
+       template
+       <
+       typename
+       Node_Update_
+       >
+       void
+       bin_search_tree_no_data_
+       <
+       Key,
+       Mapped,
+       Cmp_Fn,
+       Node_And_It_Traits,
+       Allocator >::apply_update (node_pointer p_nd, Node_Update_ *)
+     {
+       node_update ()((p_nd), ((0)));
+     }
+   }
+   namespace detail
+   {
+   template < typename Key, typename Mapped, typename Cmp_Fn, typename Node_And_It_Traits, typename Allocator > class rb_tree_no_data_:
+     bin_search_tree_no_data_
+       < Key, Mapped, Cmp_Fn, Node_And_It_Traits, Allocator >
+     {
+       typedef
+ 	bin_search_tree_no_data_
+ 	< Key, Mapped, Cmp_Fn, Node_And_It_Traits, Allocator > base_type;
+       typedef typename base_type::node_pointer node_pointer;
+     public:
+       typedef typename base_type::const_reference const_reference;
+       typedef typename base_type::point_iterator point_iterator;
+       std::pair < point_iterator, bool > insert (const_reference);
+       void insert_fixup (node_pointer);
+     };
+     template
+       <
+       typename
+       Key,
+       typename
+       Mapped,
+       typename
+       Cmp_Fn,
+       typename
+       Node_And_It_Traits,
+       typename
+       Allocator
+       >
+       std::pair
+       <
+       typename
+       rb_tree_no_data_
+       <
+       Key,
+       Mapped,
+       Cmp_Fn,
+       Node_And_It_Traits,
+       Allocator
+       >::point_iterator,
+       bool
+       >
+       rb_tree_no_data_
+       <
+       Key,
+       Mapped,
+       Cmp_Fn, Node_And_It_Traits, Allocator >::insert (const_reference)
+     {
+       std::pair < point_iterator, bool > ins_pair;
+ {
+ 	insert_fixup (ins_pair.first.m_p_nd);
+       }
+     }
+     template
+       <
+       typename
+       Key,
+       typename
+       Mapped,
+       typename
+       Cmp_Fn,
+       typename
+       Node_And_It_Traits,
+       typename
+       Allocator
+       >
+       void
+       rb_tree_no_data_
+       <
+       Key,
+       Mapped,
+       Cmp_Fn,
+       Node_And_It_Traits, Allocator >::insert_fixup (node_pointer p_nd)
+     {
+ {
+ {
+ {
+ 	    rotate_right (p_nd);
+ 	  }
+ 	}
+       }
+     }
+     template
+       <
+       typename,
+       typename, typename, typename, typename > struct container_base_dispatch;
+     template
+       <
+       typename
+       Key,
+       typename
+       Policy_Tl,
+       typename
+       Alloc
+       >
+       struct
+       container_base_dispatch
+       <Key, null_mapped_type, rb_tree_tag, Policy_Tl, Alloc >
+     {
+       typedef __gnu_cxx::typelist::at_index < Policy_Tl, 0 > at0;
+       typedef typename at0::type at0t;
+       typedef __gnu_cxx::typelist::at_index < Policy_Tl, 1 > at1;
+       typedef typename at1::type at1t;
+       typedef
+ 	rb_tree_no_data_ < Key, null_mapped_type, at0t, at1t, Alloc > type;
+     };
+     template
+       <
+       typename
+       Node_Pointer,
+       typename,
+       typename,
+       typename,
+       typename, typename, bool, class > class bin_search_tree_const_it_
+     {
+     public:
+       Node_Pointer m_p_nd;
+     };
+     template
+       <
+       typename
+       Node,
+       class
+       Const_Iterator,
+       class Iterator, class Allocator > class bin_search_tree_const_node_it_
+     {
+       typedef
+ 	typename
+ 	Allocator::template rebind < Node >::other::pointer node_pointer;
+     public:
+       typedef typename Node::metadata_type metadata_type;
+       typedef
+ 	typename
+ 	Allocator::template
+ 	rebind
+ 	< metadata_type >::other::const_reference const_metadata_reference;
+     bin_search_tree_const_node_it_ (node_pointer p_nd):
+       m_p_nd ((p_nd))
+       {}
+       const_metadata_reference get_metadata ()
+       {
+ 	return (m_p_nd->get_metadata ());
+       }
+       bin_search_tree_const_node_it_ ()
+       {}
+       bin_search_tree_const_node_it_
+ 	< Node, Const_Iterator, Iterator, Allocator > get_r_child ()
+       {
+ 	return ((m_p_nd->m_p_right));
+       }
+       bool operator == (bin_search_tree_const_node_it_)
+       {}
+       node_pointer m_p_nd;
+     };
+     template
+       <
+       typename,
+       typename,
+       class,
+       template
+       <
+       typename,
+       class,
+       class, class > class, class, class > struct bin_search_tree_traits;
+     template
+       <
+       typename
+       Key,
+       class
+       Cmp_Fn,
+       template
+       <
+       typename,
+       class,
+       class,
+       class
+       >
+       class
+       Node_Update,
+       class
+       Node,
+       class
+       Allocator
+       >
+       struct
+       bin_search_tree_traits
+       <Key, null_mapped_type, Cmp_Fn, Node_Update, Node, Allocator >
+     {
+       typedef
+ 	types_traits < Key, null_mapped_type, Allocator, false > type_traits;
+       typedef Node node;
+       typedef
+ 	bin_search_tree_const_it_
+ 	<
+ 	typename
+ 	Allocator::template
+ 	rebind
+ 	<
+ 	node
+ 	>::other::pointer,
+ 	typename
+ 	type_traits::value_type,
+ 	typename
+ 	type_traits::pointer,
+ 	typename
+ 	type_traits::const_pointer,
+ 	typename
+ 	type_traits::reference,
+ 	typename
+ 	type_traits::const_reference, true, Allocator > const_point_iterator;
+       typedef const_point_iterator point_iterator;
+       typedef
+ 	bin_search_tree_const_node_it_
+ 	<
+ 	Node,
+ 	const_point_iterator, point_iterator, Allocator > const_node_iterator;
+       typedef const_node_iterator node_iterator;
+       typedef
+ 	Node_Update
+ 	< const_node_iterator, node_iterator, Cmp_Fn, Allocator > node_update;
+     };
+     template < typename Node_Update, bool > struct tree_metadata_helper
+     {
+       typedef typename Node_Update::metadata_type type;
+     };
+     template
+       <
+       typename
+       Key,
+       typename
+       Data,
+       class
+       Cmp_Fn,
+       template
+       <
+       typename,
+       class,
+       class,
+       class
+       >
+       class Node_Update, class Allocator > struct tree_node_metadata_selector
+     {
+       typedef
+ 	dumconst_node_iterator < Key, Data, Allocator > dumconst_node_it;
+       enum
+       {
+ 	null_update = is_same < Node_Update < dumconst_node_it,
+ 	dumconst_node_it,
+ 	Cmp_Fn,
+ 	Allocator >,
+ 	null_tree_node_update < dumconst_node_it,
+ 	dumconst_node_it,
+ 	Cmp_Fn,
+ 	Allocator > >::value
+       };
+       typedef
+ 	typename
+ 	tree_metadata_helper
+ 	<
+ 	Node_Update
+ 	<
+ 	dumconst_node_it,
+ 	dumconst_node_it, Cmp_Fn, Allocator >, null_update >::type type;
+     };
+     template
+       <
+       typename,
+       typename,
+       class,
+       template
+       <
+       typename,
+       class, class, class > class, class, class > struct tree_traits;
+     template < typename Value_Type, class Metadata, class Allocator > struct rb_tree_node_
+     {
+       typedef Metadata metadata_type;
+       typedef
+ 	typename
+ 	Allocator::template
+ 	rebind
+ 	<
+ 	rb_tree_node_
+ 	< Value_Type, Metadata, Allocator > >::other::pointer node_pointer;
+       typedef
+ 	typename
+ 	Allocator::template
+ 	rebind < metadata_type >::other::reference metadata_reference;
+         metadata_reference get_metadata ()
+       {
+ 	return m_metadata;
+       }
+       node_pointer m_p_right;
+       node_pointer m_p_parent;
+       metadata_type m_metadata;
+     };
+     template
+       <
+       typename
+       Key,
+       typename
+       Mapped,
+       typename
+       Cmp_Fn,
+       template
+       <
+       typename,
+       class,
+       class,
+       class
+       >
+       class
+       Node_Update,
+       typename
+       Allocator
+       >
+       struct
+       tree_traits
+       <Key,
+       Mapped,
+       Cmp_Fn,
+       Node_Update,
+       rb_tree_tag,
+       Allocator
+       >:bin_search_tree_traits
+       <
+       Key,
+       Mapped,
+       Cmp_Fn,
+       Node_Update,
+       rb_tree_node_
+       <
+       typename
+       types_traits
+       <
+       Key,
+       Mapped,
+       Allocator,
+       false
+       >::value_type,
+       typename
+       tree_node_metadata_selector
+       <
+       Key,
+       Mapped, Cmp_Fn, Node_Update, Allocator >::type, Allocator >, Allocator >
+     {};
+   }
+ template < typename Key, typename Mapped, typename Tag, typename Policy_Tl, typename Allocator > class container_base:
+   public
+     detail::container_base_dispatch
+     < Key, Mapped, Tag, Policy_Tl, Allocator >::type
+   {};
+ template < typename Key, typename Mapped, typename Tag, typename, typename Policy_Tl, typename Allocator > class basic_tree:
+   public
+     container_base < Key, Mapped, Tag, Policy_Tl, Allocator >
+   {};
+   template
+     <
+     typename
+     Key,
+     typename
+     Mapped,
+     typename
+     Cmp_Fn
+     =
+     std::less
+     <
+     Key
+     >,
+     typename
+     Tag
+     =
+     rb_tree_tag,
+     template
+     <
+     typename,
+     typename,
+     typename,
+     typename
+     >
+     class
+     Node_Update
+     =
+     null_tree_node_update,
+     typename
+     Allocator
+     =
+     std::allocator
+     <
+     char
+     > >class
+     tree:public
+     basic_tree
+     <
+     Key,
+     Mapped,
+     Tag,
+     detail::tree_traits
+     <
+     Key,
+     Mapped,
+     Cmp_Fn,
+     Node_Update,
+     Tag,
+     Allocator
+     >,
+     typename
+     __gnu_cxx::typelist::create2
+     <
+     Cmp_Fn,
+     detail::tree_traits
+     < Key, Mapped, Cmp_Fn, Node_Update, Tag, Allocator > >::type, Allocator >
+   {};
+ }
+ using namespace std;
+ using namespace __gnu_pbds;
+ typedef
+   tree
+   <
+   int,
+   null_mapped_type,
+   less < int >, rb_tree_tag, tree_order_statistics_node_update > set_t;
+ main ()
+ {
+   set_t s;
+   s.insert (12);
+ }


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]