2007-09-06 Benjamin Kosnik <bkoz@redhat.com>

	
	PR libstdc++/29367
	* include/ext/pb_ds/detail/map_debug_base.hpp: From this..
	* include/ext/pb_ds/detail/debug_map_base.hpp: ...to this.
	Rename map_debug_base to debug_map_base, add std::pair output
	extractors, change duplicate map_debug_base typedef in containers
	to debug_base. Use m_store_extra_indicator for m_store_hash_indicator.
	* include/ext/pb_ds/*: Likewise.
	* include/Makefile.am: Same.
	* include/Makefile.in: Regenerate.
	


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@128221 138bc75d-0d04-0410-961f-82ee72b054a4

56 files changed, 196 insertions, 180 deletions

diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp
index fa0ff416b42..2bf69ba0068 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp
@@ -51,7 +51,7 @@
 #include <ext/pb_ds/exception.hpp>
 #include <ext/pb_ds/detail/eq_fn/eq_by_less.hpp>
 #include <ext/pb_ds/detail/types_traits.hpp>
-#include <ext/pb_ds/detail/map_debug_base.hpp>
+#include <ext/pb_ds/detail/debug_map_base.hpp>
 #include <ext/pb_ds/tree_policy.hpp>
 #include <ext/pb_ds/detail/cond_dealtor.hpp>
 #include <ext/pb_ds/detail/type_utils.hpp>
@@ -95,8 +95,8 @@ namespace pb_ds
 						false>
 
 #ifdef _GLIBCXX_DEBUG
-#define PB_DS_MAP_DEBUG_BASE_C_DEC					\
-    map_debug_base<Key,	eq_by_less<Key, Cmp_Fn>, \
+#define PB_DS_DEBUG_MAP_BASE_C_DEC					\
+    debug_map_base<Key,	eq_by_less<Key, Cmp_Fn>, \
 	      typename Allocator::template rebind<Key>::other::const_reference>
 #endif 
 
@@ -132,7 +132,7 @@ namespace pb_ds
 	     class Allocator>
     class PB_DS_CLASS_NAME :
 #ifdef _GLIBCXX_DEBUG
-      public PB_DS_MAP_DEBUG_BASE_C_DEC,
+      public PB_DS_DEBUG_MAP_BASE_C_DEC,
 #endif 
 #ifdef PB_DS_TREE_TRACE
       public PB_DS_TREE_TRACE_BASE_C_DEC,
@@ -162,7 +162,7 @@ namespace pb_ds
       typedef cond_dealtor< node, Allocator> cond_dealtor_t;
 
 #ifdef _GLIBCXX_DEBUG
-      typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base;
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base;
 #endif 
 
     public:
@@ -489,7 +489,7 @@ namespace pb_ds
 
 #undef PB_DS_TYPES_TRAITS_C_DEC
 
-#undef PB_DS_MAP_DEBUG_BASE_C_DEC
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
 
 #ifdef PB_DS_TREE_TRACE
 #undef PB_DS_TREE_TRACE_BASE_C_DEC
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp
index a6ee9200127..295a57aee17 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp
@@ -81,7 +81,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
 #ifdef _GLIBCXX_DEBUG
-  map_debug_base(other),
+  debug_base(other),
 #endif 
 #ifdef PB_DS_TREE_TRACE
   PB_DS_TREE_TRACE_BASE_C_DEC(other),
@@ -105,7 +105,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
       }
     catch(...)
       {
-        _GLIBCXX_DEBUG_ONLY(map_debug_base::clear();)
+        _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
 	s_node_allocator.deallocate(m_p_head, 1);
         __throw_exception_again;
       }
@@ -130,7 +130,7 @@ void
 PB_DS_CLASS_C_DEC::
 value_swap(PB_DS_CLASS_C_DEC& other)
 {
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::swap(other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other);)
   std::swap(m_p_head, other.m_p_head);
   std::swap(m_size, other.m_size);
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp
index eff970a3695..d0a0752dee0 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp
@@ -251,7 +251,7 @@ void
 PB_DS_CLASS_C_DEC::
 assert_consistent_with_debug_base() const
 {
-  map_debug_base::check_size(m_size);
+  debug_base::check_size(m_size);
   assert_consistent_with_debug_base(m_p_head->m_p_parent);
 }
 
@@ -262,7 +262,7 @@ assert_consistent_with_debug_base(const node_pointer p_nd) const
 {
   if (p_nd == NULL)
     return;
-  map_debug_base::check_key_exists(PB_DS_V2F(p_nd->m_value));
+  debug_base::check_key_exists(PB_DS_V2F(p_nd->m_value));
   assert_consistent_with_debug_base(p_nd->m_p_left);
   assert_consistent_with_debug_base(p_nd->m_p_right);
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp
index 2006a82b680..21c116f2fd0 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp
@@ -102,7 +102,7 @@ clear()
 
   initialize();
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::clear();)
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
 
     _GLIBCXX_DEBUG_ONLY(structure_only_assert_valid();)
     }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp
index 91fe41ab9d2..0f50f2262b7 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp
@@ -82,13 +82,13 @@ insert_leaf(const_reference r_value)
     {
       _GLIBCXX_DEBUG_ONLY(structure_only_assert_valid();)
 
-        _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(
+        _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(
 							PB_DS_V2F(r_value)));
 
       return (std::make_pair(p_pot, false));
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(
 							  PB_DS_V2F(r_value)));
 
   p_nd = p_pot->m_p_left;
@@ -146,7 +146,7 @@ insert_leaf_new(const_reference r_value, node_pointer p_nd, bool left_nd)
 
   update_to_top(p_new_nd, (node_update* )this);
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(
 					    PB_DS_V2F(r_value)));
 
   return (iterator(p_new_nd));
@@ -167,7 +167,7 @@ insert_imp_empty(const_reference r_value)
 
   p_new_node->m_p_left = p_new_node->m_p_right = NULL;
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(
 					    PB_DS_V2F(r_value)));
 
   update_to_top(m_p_head->m_p_parent, (node_update* )this);
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp
index 2bad9795b2b..303813ccd2f 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp
@@ -102,7 +102,7 @@ clear()
 
   initialize();
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::clear();)
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
 
     _GLIBCXX_DEBUG_ONLY(structure_only_assert_valid();)
     }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp
index 2c8e77dedf5..672560467d6 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp
@@ -71,7 +71,7 @@ join_prep(PB_DS_CLASS_C_DEC& other)
     value_swap(other);
 
   m_size += other.m_size;
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::join(other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::join(other);)
   return true;
 }
 
@@ -123,7 +123,7 @@ split_prep(const_key_reference r_key, PB_DS_CLASS_C_DEC& other)
       return false;
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::split(r_key,(Cmp_Fn& )(*this), other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::split(r_key,(Cmp_Fn& )(*this), other);)
   return true;
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
index 67c35a63b69..5636cdc1243 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
@@ -53,7 +53,7 @@
 #include <ext/pb_ds/exception.hpp>
 #include <ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp>
 #ifdef _GLIBCXX_DEBUG
-#include <ext/pb_ds/detail/map_debug_base.hpp>
+#include <ext/pb_ds/detail/debug_map_base.hpp>
 #endif 
 #ifdef PB_DS_HT_MAP_TRACE_
 #include <iostream>
@@ -92,8 +92,8 @@ namespace pb_ds
     types_traits<Key, Mapped, Allocator, Store_Hash>
 
 #ifdef _GLIBCXX_DEBUG
-#define PB_DS_MAP_DEBUG_BASE_C_DEC \
-    map_debug_base<Key,	Eq_Fn, typename Allocator::template rebind<Key>::other::const_reference>
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key,	Eq_Fn, typename Allocator::template rebind<Key>::other::const_reference>
 #endif 
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
@@ -117,7 +117,7 @@ namespace pb_ds
 	     typename Resize_Policy >
     class PB_DS_CLASS_NAME:
 #ifdef _GLIBCXX_DEBUG
-      protected PB_DS_MAP_DEBUG_BASE_C_DEC,
+      protected PB_DS_DEBUG_MAP_BASE_C_DEC,
 #endif 
       public PB_DS_HASH_EQ_FN_C_DEC,
       public Resize_Policy,
@@ -154,7 +154,7 @@ namespace pb_ds
       typedef Resize_Policy resize_base;
 
 #ifdef _GLIBCXX_DEBUG
-      typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base;
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base;
 #endif 
 
 #define PB_DS_GEN_POS std::pair<entry_pointer, typename Allocator::size_type>
@@ -390,11 +390,11 @@ namespace pb_ds
 	resize_base::notify_insert_search_end();
 	if (p_e != NULL)
 	  {
-	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+	    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
 	    return (p_e->m_value.second);
 	  }
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
 	return insert_new_imp(value_type(r_key, mapped_type()), pos)->second;
       }
 
@@ -415,11 +415,11 @@ namespace pb_ds
 	resize_base::notify_insert_search_end();
 	if (p_e != NULL)
 	  {
-	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+	    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
 	    return p_e->m_value.second;
 	  }
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
 	return insert_new_imp(value_type(r_key, mapped_type()), 
 			      pos_hash_pair)->second;
       }
@@ -445,7 +445,7 @@ namespace pb_ds
 	m_entries[pos] = p_e;
 	resize_base::notify_inserted(++m_num_used_e);
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_val));)
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
 	return &p_e->m_value;
       }
@@ -464,7 +464,7 @@ namespace pb_ds
 	p_e->m_p_next = m_entries[r_pos_hash_pair.first];
 	m_entries[r_pos_hash_pair.first] = p_e;
 	resize_base::notify_inserted(++m_num_used_e);
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_val));)
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
 	return &p_e->m_value;
       }
@@ -485,9 +485,9 @@ namespace pb_ds
 
 #ifdef _GLIBCXX_DEBUG
 	if (p_e == NULL)
-	  map_debug_base::check_key_does_not_exist(r_key);
+	  debug_base::check_key_does_not_exist(r_key);
 	else
-	  map_debug_base::check_key_exists(r_key);
+	  debug_base::check_key_exists(r_key);
 #endif 
 	return &p_e->m_value;
       }
@@ -511,9 +511,9 @@ namespace pb_ds
 
 #ifdef _GLIBCXX_DEBUG
 	if (p_e == NULL)
-	  map_debug_base::check_key_does_not_exist(r_key);
+	  debug_base::check_key_does_not_exist(r_key);
 	else
-	  map_debug_base::check_key_exists(r_key);
+	  debug_base::check_key_exists(r_key);
 #endif 
 	return &p_e->m_value;
       }
@@ -632,7 +632,7 @@ namespace pb_ds
 #undef PB_DS_HASH_EQ_FN_C_DEC
 #undef PB_DS_RANGED_HASH_FN_C_DEC
 #undef PB_DS_TYPES_TRAITS_C_DEC
-#undef PB_DS_MAP_DEBUG_BASE_C_DEC
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
 #undef PB_DS_CLASS_NAME
 #undef PB_DS_V2F
 #undef PB_DS_V2S
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp
index 9223da5d6f9..3a4c422839d 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp
@@ -68,7 +68,7 @@ cmp_with_other(const Other_Map_Type& other) const
 
       const_mapped_pointer p_mapped_value =
 	const_cast<PB_DS_CLASS_C_DEC& >(*this).
-	find_key_pointer(r_key, traits_base::m_store_hash_indicator);
+	find_key_pointer(r_key, traits_base::m_store_extra_indicator);
 
       if (p_mapped_value == NULL)
 	return false;
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
index 7da4d8a1e79..e767bbec51f 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
@@ -130,7 +130,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
 #ifdef _GLIBCXX_DEBUG
-  map_debug_base(other),
+  debug_base(other),
 #endif 
   PB_DS_HASH_EQ_FN_C_DEC(other),
   resize_base(other), ranged_hash_fn_base(other),
@@ -171,7 +171,7 @@ swap(PB_DS_CLASS_C_DEC& other)
   hash_eq_fn_base::swap(other);
   resize_base::swap(other);
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::swap(other));
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other));
   _GLIBCXX_DEBUG_ONLY(assert_valid());
   _GLIBCXX_DEBUG_ONLY(other.assert_valid());
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
index f2b41b37bca..2d4859a6106 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
@@ -57,5 +57,5 @@ constructor_insert_new_imp(const_mapped_reference r_val, size_type pos,
   // At this point no exceptions can be thrown.
   p->m_p_next = m_entries[pos];
   m_entries[pos] = p;
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(r_key);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(r_key);)
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
index 08a0b7b3fce..52759dec20d 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
@@ -58,5 +58,5 @@ constructor_insert_new_imp(const_reference r_val, size_type pos, true_type)
   p->m_hash = ranged_hash_fn_base::operator()((const_key_reference)(PB_DS_V2F(p->m_value))).second;
 
   m_entries[pos] = p;
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(r_key);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(r_key);)
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
index 61cbfa90d2e..fdf7dbcad35 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
@@ -51,7 +51,7 @@ void
 PB_DS_CLASS_C_DEC::
 assert_valid() const
 {
-  map_debug_base::check_size(m_num_used_e);
+  debug_base::check_size(m_num_used_e);
   assert_entry_pointer_array_valid(m_entries);
 }
 
@@ -67,7 +67,7 @@ assert_entry_pointer_array_valid(const entry_pointer_array a_p_entries) const
       while (p_e != NULL)
         {
 	  ++iterated_num_used_e;
-	  assert_entry_pointer_valid(p_e, traits_base::m_store_hash_indicator);
+	  assert_entry_pointer_valid(p_e, traits_base::m_store_extra_indicator);
 	  p_e = p_e->m_p_next;
         }
     }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp
index d179a3dc941..4e01b6ae152 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp
@@ -50,6 +50,6 @@ PB_DS_CLASS_T_DEC
 void
 PB_DS_CLASS_C_DEC::
 assert_entry_pointer_valid(const entry_pointer p, false_type) const
-{ map_debug_base::check_key_exists(PB_DS_V2F(p->m_value)); }
+{ debug_base::check_key_exists(PB_DS_V2F(p->m_value)); }
 
 #endif 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp
index 48dc555abea..2e7e2ff3482 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp
@@ -51,7 +51,7 @@ void
 PB_DS_CLASS_C_DEC::
 assert_entry_pointer_valid(const entry_pointer p_e, true_type) const
 {
-  map_debug_base::check_key_exists(PB_DS_V2F(p_e->m_value));
+  debug_base::check_key_exists(PB_DS_V2F(p_e->m_value));
   comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(PB_DS_V2F(p_e->m_value));
   _GLIBCXX_DEBUG_ASSERT(p_e->m_hash == pos_hash_pair.second);
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
index 265a7052780..95c3fed7a45 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
@@ -49,7 +49,7 @@ inline void
 PB_DS_CLASS_C_DEC::
 erase_entry_pointer(entry_pointer& r_p_e)
 {
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::erase_existing(PB_DS_V2F(r_p_e->m_value)));
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(r_p_e->m_value)));
 
   entry_pointer p_e = r_p_e;
   r_p_e = r_p_e->m_p_next;
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
index 13a3a6d4d34..28553b1a8dd 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
@@ -65,7 +65,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos)
   if (p_e == NULL)
     {
       resize_base::notify_erase_search_end();
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
       return false;
     }
@@ -73,7 +73,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos)
   if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key))
     {
       resize_base::notify_erase_search_end();
-      _GLIBCXX_DEBUG_ONLY(map_debug_base:: check_key_exists(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base:: check_key_exists(r_key);)
       erase_entry_pointer(m_entries[pos]);
       do_resize_if_needed_no_throw();
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -86,7 +86,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos)
       if (p_next_e == NULL)
         {
 	  resize_base::notify_erase_search_end();
-	  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+	  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
           _GLIBCXX_DEBUG_ONLY(assert_valid();)
           return false;
         }
@@ -94,7 +94,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos)
       if (hash_eq_fn_base::operator()(PB_DS_V2F(p_next_e->m_value), r_key))
         {
 	  resize_base::notify_erase_search_end();
-	  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+	  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
           erase_entry_pointer(p_e->m_p_next);
 	  do_resize_if_needed_no_throw();
 	  _GLIBCXX_DEBUG_ONLY(assert_valid();)
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
index 7eb821e0fe6..a6eff1fc4e6 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
@@ -56,7 +56,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair)
   if (p_e == NULL)
     {
       resize_base::notify_erase_search_end();
-      _GLIBCXX_DEBUG_ONLY(map_debug_base:: check_key_does_not_exist(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base:: check_key_does_not_exist(r_key);)
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
       return false;
     }
@@ -65,7 +65,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair)
 				  r_key, r_pos_hash_pair.second))
     {
       resize_base::notify_erase_search_end();
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
       erase_entry_pointer(m_entries[r_pos_hash_pair.first]);
       do_resize_if_needed_no_throw();
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -78,7 +78,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair)
       if (p_next_e == NULL)
         {
 	  resize_base::notify_erase_search_end();
-	  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+	  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
           _GLIBCXX_DEBUG_ONLY(assert_valid();)
           return false;
         }
@@ -88,7 +88,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair)
 				      r_pos_hash_pair.second))
         {
 	  resize_base::notify_erase_search_end();
-	  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+	  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
           erase_entry_pointer(p_e->m_p_next);
 	  do_resize_if_needed_no_throw();
 	  _GLIBCXX_DEBUG_ONLY(assert_valid();)
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp
index 519072a2e9e..ee85ed1dcdc 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp
@@ -85,7 +85,7 @@ cmp_with_other(const Other_Map_Type& other) const
       const_key_reference r_key =(const_key_reference)PB_DS_V2F(*it);
       const_mapped_pointer p_mapped_value =
 	const_cast<PB_DS_CLASS_C_DEC& >(*this).
-	find_key_pointer(r_key, traits_base::m_store_hash_indicator);
+	find_key_pointer(r_key, traits_base::m_store_extra_indicator);
 
       if (p_mapped_value == NULL)
 	return false;
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
index fd158f921ad..516a409e0a8 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
@@ -66,11 +66,11 @@ insert_imp(const_reference r_val, false_type)
   resize_base::notify_insert_search_end();
   if (p_e != NULL)
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
       return std::make_pair(&p_e->m_value, false);
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
   return std::make_pair(insert_new_imp(r_val, pos), true);
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
index 128e11fdc0f..d7d0a61155b 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
@@ -67,11 +67,11 @@ insert_imp(const_reference r_val, true_type)
   resize_base::notify_insert_search_end();
   if (p_e != NULL)
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(key);)
       return std::make_pair(&p_e->m_value, false);
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
   return std::make_pair(insert_new_imp(r_val, pos_hash_pair), true);
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/map_debug_base.hpp b/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp
index 95c164ace00..373b0f6c78e 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/map_debug_base.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp
@@ -40,12 +40,12 @@
 // warranty.
  
 /**
- * @file map_debug_base.hpp
+ * @file debug_map_base.hpp
  * Contains a debug-mode base for all maps.
  */
 
-#ifndef PB_DS_MAP_DEBUG_BASE_HPP
-#define PB_DS_MAP_DEBUG_BASE_HPP
+#ifndef PB_DS_DEBUG_MAP_BASE_HPP
+#define PB_DS_DEBUG_MAP_BASE_HPP
 
 #ifdef _GLIBCXX_DEBUG
 
@@ -59,15 +59,21 @@ namespace pb_ds
 {
   namespace detail
   {
+    // Need std::pair ostream extractor.
+    template<typename _CharT, typename _Traits, typename _Tp1, typename _Tp2>
+    inline std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __out, 
+	       const std::pair<_Tp1, _Tp2>& p)
+    { return (__out << '(' << p.first << ',' << p.second << ')'); }
 
 #define PB_DS_CLASS_T_DEC \
     template<typename Key, class Eq_Fn, typename Const_Key_Reference>
 
 #define PB_DS_CLASS_C_DEC \
-    map_debug_base<Key, Eq_Fn, Const_Key_Reference>
+    debug_map_base<Key, Eq_Fn, Const_Key_Reference>
 
     template<typename Key, class Eq_Fn, typename Const_Key_Reference>
-    class map_debug_base
+    class debug_map_base
     {
     private:
       typedef typename std::allocator< Key> key_allocator;
@@ -77,11 +83,11 @@ namespace pb_ds
       typedef Const_Key_Reference const_key_reference;
 
     protected:
-      map_debug_base();
+      debug_map_base();
 
-      map_debug_base(const PB_DS_CLASS_C_DEC& other);
+      debug_map_base(const PB_DS_CLASS_C_DEC& other);
 
-      ~map_debug_base();
+      ~debug_map_base();
 
       inline void
       insert_new(const_key_reference r_key);
@@ -133,17 +139,17 @@ namespace pb_ds
 
     PB_DS_CLASS_T_DEC
     PB_DS_CLASS_C_DEC::
-    map_debug_base()
+    debug_map_base()
     { _GLIBCXX_DEBUG_ONLY(assert_valid();) }
 
     PB_DS_CLASS_T_DEC
     PB_DS_CLASS_C_DEC::
-    map_debug_base(const PB_DS_CLASS_C_DEC& other) : m_key_set(other.m_key_set)
+    debug_map_base(const PB_DS_CLASS_C_DEC& other) : m_key_set(other.m_key_set)
     { _GLIBCXX_DEBUG_ONLY(assert_valid();) }
 
     PB_DS_CLASS_T_DEC
     PB_DS_CLASS_C_DEC::
-    ~map_debug_base()
+    ~debug_map_base()
     { _GLIBCXX_DEBUG_ONLY(assert_valid();) }
 
     PB_DS_CLASS_T_DEC
@@ -157,7 +163,7 @@ namespace pb_ds
       alloc.set_throw_prob(0);
       if (find(r_key) != m_key_set.end())
 	{
-	  std::cerr << "insert_new " << r_key << std::endl;
+	  std::cerr << "insert_new" << r_key << std::endl;
 	  std::abort();
 	}
 
@@ -167,7 +173,7 @@ namespace pb_ds
 	}
       catch(...)
 	{
-	  std::cerr << "insert_new 1" << r_key << std::endl;
+	  std::cerr << "insert_new" << r_key << std::endl;
 	  std::abort();
 	}
       alloc.set_throw_prob(orig_throw_prob);
@@ -183,7 +189,7 @@ namespace pb_ds
       key_set_iterator it = find(r_key);
       if (it == m_key_set.end())
 	{
-	  std::cerr << "erase_existing " << r_key << std::endl;
+	  std::cerr << "erase_existing" << r_key << std::endl;
 	  std::abort();
 	}
       m_key_set.erase(it);
@@ -208,7 +214,7 @@ namespace pb_ds
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
       if (find(r_key) == m_key_set.end())
         {
-          std::cerr << "check_key_exists " << r_key << std::endl;
+          std::cerr << "check_key_exists" << r_key << std::endl;
           std::abort();
         }
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
@@ -222,7 +228,9 @@ namespace pb_ds
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
       if (find(r_key) != m_key_set.end())
         {
-	  std::cerr << "check_key_does_not_exist " << r_key << std::endl;
+	  using std::cerr;
+	  using std::endl;
+	  cerr << "check_key_does_not_exist" << r_key << endl;
           std::abort();
         }
     }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
index 30b8d3e7b73..6f4844cf00d 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
@@ -140,7 +140,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
 #ifdef _GLIBCXX_DEBUG
-  map_debug_base(other),
+  debug_base(other),
 #endif 
   hash_eq_fn_base(other),
   resize_base(other),
@@ -187,7 +187,7 @@ swap(PB_DS_CLASS_C_DEC& other)
   ranged_probe_fn_base::swap(other);
   hash_eq_fn_base::swap(other);
   resize_base::swap(other);
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::swap(other));
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other));
   _GLIBCXX_DEBUG_ONLY(assert_valid());
   _GLIBCXX_DEBUG_ONLY(other.assert_valid());
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
index df4af951f1a..30df973b1eb 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
@@ -55,5 +55,5 @@ constructor_insert_new_imp(const_mapped_reference r_val, size_type pos,
   entry* const p_e = m_entries + pos;
   new (&p_e->m_value) mapped_value_type(r_val);
   p_e->m_stat = valid_entry_status;
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(p_e->m_value.first);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(p_e->m_value.first);)
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
index 0e17e36efc1..df8797ae7e7 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
@@ -56,5 +56,5 @@ constructor_insert_new_imp(const_mapped_reference r_val, size_type pos,
   new (&p_e->m_value) mapped_value_type(r_val);
   p_e->m_hash = ranged_probe_fn_base::operator()(PB_DS_V2F(r_val)).second;
   p_e->m_stat = valid_entry_status;
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(p_e->m_value.first);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(p_e->m_value.first);)
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
index fd8ca9abe12..15bae0d9d6c 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
@@ -51,7 +51,7 @@ void
 PB_DS_CLASS_C_DEC::
 assert_valid() const
 {
-  map_debug_base::check_size(m_num_used_e);
+  debug_base::check_size(m_num_used_e);
   assert_entry_array_valid(m_entries, traits_base::m_store_extra_indicator);
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp
index 9d3d428e3af..1a8e525e724 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp
@@ -63,7 +63,7 @@ assert_entry_array_valid(const entry_array a_entries, false_type) const
         case valid_entry_status:
 	  {
 	    const_key_reference r_key = PB_DS_V2F(p_e->m_value);
-	    map_debug_base::check_key_exists(r_key);
+	    debug_base::check_key_exists(r_key);
 	    ++iterated_num_used_e;
 	    break;
 	  }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp
index a4d8b6c651a..7acfe4c0f81 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp
@@ -64,7 +64,7 @@ assert_entry_array_valid(const entry_array a_entries, true_type) const
         case valid_entry_status:
 	  {
 	    const_key_reference r_key = PB_DS_V2F(p_e->m_value);
-	    map_debug_base::check_key_exists(r_key);
+	    debug_base::check_key_exists(r_key);
 
 	    const comp_hash pos_hash_pair = ranged_probe_fn_base::operator()(r_key);
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
index 9da85072586..3d194cf365f 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
@@ -50,7 +50,7 @@ PB_DS_CLASS_C_DEC::
 erase_entry(entry_pointer p_e)
 {
   _GLIBCXX_DEBUG_ASSERT(p_e->m_stat = valid_entry_status);
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::erase_existing(PB_DS_V2F(p_e->m_value));)
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_e->m_value));)
   p_e->m_value.~value_type();
   p_e->m_stat = erased_entry_status;
   _GLIBCXX_DEBUG_ASSERT(m_num_used_e > 0);
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
index 51acec9d4b3..a8959278b63 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
@@ -64,7 +64,7 @@ erase_imp(const_key_reference r_key,  false_type)
         case empty_entry_status:
 	  {
 	    resize_base::notify_erase_search_end();
-	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(
+	    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(
 								    r_key));
 	    return false;
 	  }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
index 71c498b4698..cf479082a7a 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
@@ -63,7 +63,7 @@ erase_imp(const_key_reference r_key, true_type)
         case empty_entry_status:
 	  {
 	    resize_base::notify_erase_search_end();
-	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(
+	    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(
 								    r_key));
 	    return false;
 	  }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
index 24a9f1bf3ba..88f250162ad 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
@@ -54,7 +54,7 @@
 #include <iostream>
 #endif 
 #ifdef _GLIBCXX_DEBUG
-#include <ext/pb_ds/detail/map_debug_base.hpp>
+#include <ext/pb_ds/detail/debug_map_base.hpp>
 #endif
 #include <debug/debug.h>
 
@@ -89,8 +89,8 @@ namespace pb_ds
     types_traits<Key, Mapped, Allocator, Store_Hash>
 
 #ifdef _GLIBCXX_DEBUG
-#define PB_DS_MAP_DEBUG_BASE_C_DEC \
-    map_debug_base<Key, Eq_Fn, typename Allocator::template rebind<Key>::other::const_reference>
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key, Eq_Fn, typename Allocator::template rebind<Key>::other::const_reference>
 #endif 
 
 #ifdef PB_DS_DATA_TRUE_INDICATOR
@@ -114,7 +114,7 @@ namespace pb_ds
 	     typename Resize_Policy>
     class PB_DS_CLASS_NAME :
 #ifdef _GLIBCXX_DEBUG
-      protected PB_DS_MAP_DEBUG_BASE_C_DEC,
+      protected PB_DS_DEBUG_MAP_BASE_C_DEC,
 #endif 
       public PB_DS_HASH_EQ_FN_C_DEC,
       public Resize_Policy,
@@ -152,7 +152,7 @@ namespace pb_ds
       typedef PB_DS_RANGED_PROBE_FN_C_DEC ranged_probe_fn_base;
 
 #ifdef _GLIBCXX_DEBUG
-      typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base;
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base;
 #endif 
 
       typedef PB_DS_HASH_EQ_FN_C_DEC hash_eq_fn_base;
@@ -410,7 +410,7 @@ namespace pb_ds
 	p_e->m_stat = valid_entry_status;
 	resize_base::notify_inserted(++m_num_used_e);
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(p_e->m_value));)
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(p_e->m_value));)
 
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
 	return &p_e->m_value;
@@ -436,7 +436,7 @@ namespace pb_ds
 
 	resize_base::notify_inserted(++m_num_used_e);
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(p_e->m_value));)
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(p_e->m_value));)
 
 	_GLIBCXX_DEBUG_ONLY(assert_valid();)
 	return &p_e->m_value;
@@ -455,7 +455,7 @@ namespace pb_ds
 	if (p_e->m_stat != valid_entry_status)
 	  return insert_new_imp(value_type(key, mapped_type()), pos)->second;
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);)	  
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(key);)	  
 	return p_e->m_value.second;
       }
 
@@ -471,7 +471,7 @@ namespace pb_ds
 	  return insert_new_imp(value_type(key, mapped_type()),
 				 pos_hash_pair)->second;
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key));
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(key));
 	return (m_entries + pos_hash_pair.first)->m_value.second;
       }
 #endif
@@ -494,7 +494,7 @@ namespace pb_ds
 	      case empty_entry_status:
 		{
 		  resize_base::notify_find_search_end();
-		  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
+		  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
 
 		    return NULL;
 		}
@@ -503,7 +503,7 @@ namespace pb_ds
 		if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), key))
 		  {
 		    resize_base::notify_find_search_end();
-		    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);)
+		    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(key);)
 
 		    return pointer(&p_e->m_value);
 		  }
@@ -517,7 +517,7 @@ namespace pb_ds
 	    resize_base::notify_find_search_collision();
 	  }
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
 	resize_base::notify_find_search_end();
 	return NULL;
       }
@@ -542,7 +542,7 @@ namespace pb_ds
 	      case empty_entry_status:
 		{
 		  resize_base::notify_find_search_end();
-		  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
+		  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
 
 		  return NULL;
 		}
@@ -553,7 +553,7 @@ namespace pb_ds
 						key, pos_hash_pair.second))
 		  {
 		    resize_base::notify_find_search_end();
-		    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(key);)
+		    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(key);)
 		    return pointer(&p_e->m_value);
 		  }
 		break;
@@ -566,7 +566,7 @@ namespace pb_ds
 	    resize_base::notify_find_search_collision();
 	  }
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(key);)
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);)
 	resize_base::notify_find_search_end();
 	return NULL;
       }
@@ -673,7 +673,7 @@ namespace pb_ds
 #undef PB_DS_HASH_EQ_FN_C_DEC
 #undef PB_DS_RANGED_PROBE_FN_C_DEC
 #undef PB_DS_TYPES_TRAITS_C_DEC
-#undef PB_DS_MAP_DEBUG_BASE_C_DEC
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
 #undef PB_DS_CLASS_NAME
 #undef PB_DS_V2F
 #undef PB_DS_V2S
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
index 98d597051bd..b5b00bd08ba 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
@@ -68,7 +68,7 @@ find_ins_pos(const_key_reference r_key, false_type)
         case empty_entry_status:
 	  {
             resize_base::notify_insert_search_end();
-            _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+            _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
 	    return (ins_pos == m_num_e) ? pos : ins_pos;
 	  }
 	  break;
@@ -80,7 +80,7 @@ find_ins_pos(const_key_reference r_key, false_type)
 	  if (hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key))
             {
 	      resize_base::notify_insert_search_end();
-	      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+	      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
                 return pos;
             }
 	  break;
@@ -107,11 +107,11 @@ insert_imp(const_reference r_val, false_type)
 
   if (m_entries[pos].m_stat == valid_entry_status)
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
       return std::make_pair(&(m_entries + pos)->m_value, false);
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key));
   return std::make_pair(insert_new_imp(r_val, pos), true);
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
index b6445fae2e6..407fcd2591f 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
@@ -70,7 +70,7 @@ find_ins_pos(const_key_reference r_key, true_type)
         case empty_entry_status:
 	  {
             resize_base::notify_insert_search_end();
-            _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+            _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
 
 	    return ((ins_pos == m_num_e) ?
 		     std::make_pair(pos, pos_hash_pair.second) :
@@ -86,7 +86,7 @@ find_ins_pos(const_key_reference r_key, true_type)
 					  r_key, pos_hash_pair.second))
             {
 	      resize_base::notify_insert_search_end();
-	      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+	      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
               return std::make_pair(pos, pos_hash_pair.second);
             }
 	  break;
@@ -114,11 +114,11 @@ insert_imp(const_reference r_val, true_type)
   entry_pointer p_e =& m_entries[pos_hash_pair.first];
   if (p_e->m_stat == valid_entry_status)
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key));
       return std::make_pair(&p_e->m_value, false);
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key));
   return std::make_pair(insert_new_imp(r_val, pos_hash_pair), true);
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp
index a311a79757d..a3d96ec2f28 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp
@@ -89,7 +89,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) : 
 #ifdef _GLIBCXX_DEBUG
-  map_debug_base(),
+  debug_base(),
 #endif
 m_p_l(NULL)
 {
@@ -119,7 +119,7 @@ swap(PB_DS_CLASS_C_DEC& other)
 {
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::swap(other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other);)
   std::swap(m_p_l, other.m_p_l);
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   _GLIBCXX_DEBUG_ONLY(other.assert_valid();)
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp
index 1427f83749b..0ccfc97d136 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp
@@ -54,10 +54,10 @@ assert_valid() const
   size_type calc_size = 0;
   for (const_iterator it = begin(); it != end(); ++it)
     {
-      map_debug_base::check_key_exists(PB_DS_V2F(*it));
+      debug_base::check_key_exists(PB_DS_V2F(*it));
       ++calc_size;
     }
-  map_debug_base::check_size(calc_size);
+  debug_base::check_size(calc_size);
 }
 
 #endif 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp
index 85ac02d3012..d4ee2a18163 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp
@@ -134,7 +134,7 @@ void
 PB_DS_CLASS_C_DEC::
 actual_erase_entry(entry_pointer p_l)
 {
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::erase_existing(PB_DS_V2F(p_l->m_value));)
+  _GLIBCXX_DEBUG_ONLY(debug_base::erase_existing(PB_DS_V2F(p_l->m_value));)
   p_l->~entry();
   s_entry_allocator.deallocate(p_l, 1);
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp
index 37c173de1e4..8c792b02290 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp
@@ -54,7 +54,7 @@ find_imp(const_key_reference r_key) const
   if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value)))
     {
       apply_update(m_p_l, s_metadata_type_indicator);
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);)
       return m_p_l;
     }
 
@@ -77,7 +77,7 @@ find_imp(const_key_reference r_key) const
 	p_l = p_next;
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
   return NULL;
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp
index af60c07b507..c494c2614d4 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp
@@ -56,11 +56,11 @@ insert(const_reference r_val)
 
   if (p_l != NULL)
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(PB_DS_V2F(r_val));)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(PB_DS_V2F(r_val));)
       return std::make_pair(point_iterator(&p_l->m_value), false);
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(PB_DS_V2F(r_val));)
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(PB_DS_V2F(r_val));)
 
   p_l = allocate_new_entry(r_val, traits_base::m_no_throw_copies_indicator);
   p_l->m_p_next = m_p_l;
@@ -80,7 +80,7 @@ allocate_new_entry(const_reference r_val, false_type)
     value_type(r_val);
 
   cond.set_no_action();
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_val));)
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
   init_entry_metadata(p_l, s_metadata_type_indicator);
   return p_l;
 }
@@ -92,7 +92,7 @@ allocate_new_entry(const_reference    r_val, true_type)
 {
   entry_pointer p_l = s_entry_allocator.allocate(1);
   new (&p_l->m_value) value_type(r_val);
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_val));)
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)
   init_entry_metadata(p_l, s_metadata_type_indicator);
   return p_l;
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp
index e99dc735ab4..f39baa0f39d 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp
@@ -52,7 +52,7 @@
 #include <ext/pb_ds/detail/list_update_map_/entry_metadata_base.hpp>
 #include <ext/pb_ds/exception.hpp>
 #ifdef _GLIBCXX_DEBUG
-#include <ext/pb_ds/detail/map_debug_base.hpp>
+#include <ext/pb_ds/detail/debug_map_base.hpp>
 #endif 
 #ifdef PB_DS_LU_MAP_TRACE_
 #include <iostream>
@@ -82,8 +82,8 @@ namespace pb_ds
     types_traits<Key, Mapped, Allocator, false>
 
 #ifdef _GLIBCXX_DEBUG
-#define PB_DS_MAP_DEBUG_BASE_C_DEC \
-    map_debug_base<Key, Eq_Fn, \
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key, Eq_Fn, \
 	      typename Allocator::template rebind<Key>::other::const_reference>
 #endif 
 
@@ -108,7 +108,7 @@ namespace pb_ds
 	     class Update_Policy>
     class PB_DS_CLASS_NAME :
 #ifdef _GLIBCXX_DEBUG
-      protected PB_DS_MAP_DEBUG_BASE_C_DEC,
+      protected PB_DS_DEBUG_MAP_BASE_C_DEC,
 #endif 
       public PB_DS_TYPES_TRAITS_C_DEC
     {
@@ -148,7 +148,7 @@ namespace pb_ds
 
 
 #ifdef _GLIBCXX_DEBUG
-      typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base;
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base;
 #endif 
 
       typedef cond_dealtor<entry, Allocator> cond_dealtor_t;
@@ -355,7 +355,7 @@ namespace pb_ds
 #undef PB_DS_CLASS_T_DEC
 #undef PB_DS_CLASS_C_DEC
 #undef  PB_DS_TYPES_TRAITS_C_DEC
-#undef PB_DS_MAP_DEBUG_BASE_C_DEC
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
 #undef PB_DS_CLASS_NAME
 #undef PB_DS_V2F
 #undef PB_DS_EP2VP
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp
index 83a47250f83..0f50317b879 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp
@@ -86,7 +86,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_OV_TREE_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
 #ifdef _GLIBCXX_DEBUG
-  map_debug_base(other),
+  debug_base(other),
 #endif 
 #ifdef PB_DS_TREE_TRACE
   PB_DS_TREE_TRACE_BASE_C_DEC(other),
@@ -166,7 +166,7 @@ copy_from_ordered_range(It first_it, It last_it)
   const_iterator dbg_it = m_a_values;
   while (dbg_it != m_end_it)
     {
-      map_debug_base::insert_new(PB_DS_V2F(*dbg_it));
+      debug_base::insert_new(PB_DS_V2F(*dbg_it));
       dbg_it++;
     }
   PB_DS_CLASS_C_DEC::assert_valid();
@@ -219,7 +219,7 @@ copy_from_ordered_range(It first_it, It last_it, It other_first_it,
   const_iterator dbg_it = m_a_values;
   while (dbg_it != m_end_it)
     {
-      map_debug_base::insert_new(PB_DS_V2F(*dbg_it));
+      debug_base::insert_new(PB_DS_V2F(*dbg_it));
       dbg_it++;
     }
   PB_DS_CLASS_C_DEC::assert_valid();
@@ -246,7 +246,7 @@ value_swap(PB_DS_CLASS_C_DEC& other)
   std::swap(m_a_metadata, other.m_a_metadata);
   std::swap(m_size, other.m_size);
   std::swap(m_end_it, other.m_end_it);
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::swap(other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other);)
 }
 
 PB_DS_CLASS_T_DEC
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp
index b1a36555ce3..abbbc0f59bd 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp
@@ -66,14 +66,14 @@ void
 PB_DS_CLASS_C_DEC::
 assert_iterators() const
 {
-  map_debug_base::check_size(m_size);
+  debug_base::check_size(m_size);
   size_type iterated_num = 0;
   const_iterator prev_it = end();
   _GLIBCXX_DEBUG_ASSERT( m_end_it == m_a_values + m_size);
   for (const_iterator it = begin(); it != end(); ++it)
     {
       ++iterated_num;
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(PB_DS_V2F(*it));)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(PB_DS_V2F(*it));)
       _GLIBCXX_DEBUG_ASSERT(lower_bound(PB_DS_V2F(*it)) == it);
       const_iterator upper_bound_it = upper_bound(PB_DS_V2F(*it));
       --upper_bound_it;
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp
index 936d5492e8d..18f9e1ce845 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp
@@ -61,7 +61,7 @@ clear()
       cond_dtor<size_type> cd(m_a_values, m_end_it, m_size);
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::clear();)
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
   m_a_values = NULL;
   m_size = 0;
   m_end_it = m_a_values;
@@ -98,7 +98,7 @@ erase_if(Pred pred)
   value_vector a_new_values = s_value_alloc.allocate(new_size);
   iterator target_it = a_new_values;
   cond_dtor<size_type> cd(a_new_values, target_it, new_size);
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::clear());
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear());
   for (source_it = begin(); source_it != m_end_it; ++source_it)
     {
       if (!pred(*source_it))
@@ -106,7 +106,7 @@ erase_if(Pred pred)
 	  new (const_cast<void*>(static_cast<const void* >(target_it)))
 	    value_type(*source_it);
 
-	  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(*source_it)));
+	  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(*source_it)));
 	  ++target_it;
         }
     }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
index f9e27144312..78fdcf96c24 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
@@ -49,7 +49,7 @@
 #include <ext/pb_ds/tree_policy.hpp>
 #include <ext/pb_ds/detail/eq_fn/eq_by_less.hpp>
 #include <ext/pb_ds/detail/types_traits.hpp>
-#include <ext/pb_ds/detail/map_debug_base.hpp>
+#include <ext/pb_ds/detail/debug_map_base.hpp>
 #include <ext/pb_ds/detail/type_utils.hpp>
 #include <ext/pb_ds/exception.hpp>
 #include <ext/pb_ds/detail/tree_trace_base.hpp>
@@ -89,8 +89,8 @@ namespace pb_ds
     types_traits<Key, Mapped, Allocator, false>
 
 #ifdef _GLIBCXX_DEBUG
-#define PB_DS_MAP_DEBUG_BASE_C_DEC \
-    map_debug_base<Key, eq_by_less<Key, Cmp_Fn>, \
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key, eq_by_less<Key, Cmp_Fn>, \
        	typename Allocator::template rebind<Key>::other::const_reference>
 #endif 
 
@@ -118,7 +118,7 @@ namespace pb_ds
 	     class Node_And_It_Traits, class Allocator>
     class PB_DS_OV_TREE_CLASS_NAME :
 #ifdef _GLIBCXX_DEBUG
-      protected PB_DS_MAP_DEBUG_BASE_C_DEC,
+      protected PB_DS_DEBUG_MAP_BASE_C_DEC,
 #endif 
 #ifdef PB_DS_TREE_TRACE
       public PB_DS_TREE_TRACE_BASE_C_DEC,
@@ -139,7 +139,7 @@ namespace pb_ds
       typedef Cmp_Fn cmp_fn_base;
 
 #ifdef _GLIBCXX_DEBUG
-      typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base;
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base;
 #endif 
 
       typedef typename traits_base::pointer mapped_pointer_;
@@ -244,7 +244,7 @@ namespace pb_ds
 	point_iterator it = lower_bound(r_key);
 	if (it != end() && !Cmp_Fn::operator()(r_key, PB_DS_V2F(*it)))
 	  {
-	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
+	    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key));
 	    _GLIBCXX_DEBUG_ONLY(assert_valid();)
 	     return it->second;
 	  }
@@ -267,7 +267,7 @@ namespace pb_ds
 	if (it != end()&&  !Cmp_Fn::operator()(r_key, PB_DS_V2F(*it)))
 	  {
 	    _GLIBCXX_DEBUG_ONLY(assert_valid();)
-	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
+	    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key));
 	    return std::make_pair(it, false);
 	  }
 
@@ -301,11 +301,11 @@ namespace pb_ds
 	iterator pot_it = lower_bound(r_key);
 	if (pot_it != end()&&  !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it)))
 	  {
-	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
+	    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key));
 	    return ++pot_it;
 	  }
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key));
 	return pot_it;
       }
 
@@ -320,11 +320,11 @@ namespace pb_ds
 	iterator pot_it = lower_bound(r_key);
 	if (pot_it != end() && !Cmp_Fn::operator()(r_key, PB_DS_V2F(*pot_it)))
 	  {
-	    _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
+	    _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key));
 	    return pot_it;
 	  }
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key));
 	return end();
       }
 
@@ -423,7 +423,7 @@ namespace pb_ds
 	  typename Allocator::group_throw_prob_adjustor adjust(m_size);
 #endif 
 
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(PB_DS_V2F(r_value)));
+	_GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(PB_DS_V2F(r_value)));
 
 	value_vector a_values = s_value_alloc.allocate(m_size + 1);
 
@@ -461,7 +461,7 @@ namespace pb_ds
 	++m_size;
 	m_a_values = a_values;
 	m_end_it = m_a_values + m_size;
-	_GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_value)));
+	_GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_value)));
 	update(node_begin(), (node_update* )this);
 	_GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();)
 	return ret_it;
@@ -514,7 +514,7 @@ namespace pb_ds
 #undef PB_DS_CLASS_T_DEC
 #undef PB_DS_OV_TREE_CLASS_NAME
 #undef PB_DS_TYPES_TRAITS_C_DEC
-#undef PB_DS_MAP_DEBUG_BASE_C_DEC
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
 #ifdef PB_DS_TREE_TRACE
 #undef PB_DS_TREE_TRACE_BASE_C_DEC
 #endif 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp
index 3b6abcd6c77..9528c412510 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp
@@ -83,7 +83,7 @@ split(const_key_reference r_key, PB_DS_CLASS_C_DEC& other)
       return;
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::join(other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::join(other);)
   iterator it = upper_bound(r_key);
   PB_DS_CLASS_C_DEC new_other(other, other);
   new_other.copy_from_ordered_range(it, end());
@@ -91,7 +91,7 @@ split(const_key_reference r_key, PB_DS_CLASS_C_DEC& other)
   new_this.copy_from_ordered_range(begin(), it);
 
   // No exceptions from this point.
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::split(r_key,(Cmp_Fn& )(*this), other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::split(r_key,(Cmp_Fn& )(*this), other);)
   other.update(other.node_begin(), (node_update* )(&other));
   update(node_begin(), (node_update* )this);
   other.value_swap(new_other);
@@ -135,7 +135,7 @@ join(PB_DS_CLASS_C_DEC& other)
 				     begin(), end());
 
   // No exceptions from this point.
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::join(other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::join(other);)
   value_swap(new_this);
   other.clear();
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp
index a5a96a5a389..efa2e6104e5 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp
@@ -81,7 +81,7 @@ PB_DS_CLASS_T_DEC
 PB_DS_CLASS_C_DEC::
 PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) :
 #ifdef _GLIBCXX_DEBUG
-  map_debug_base(other),
+  debug_base(other),
 #endif 
   synth_e_access_traits(other),
   node_update(other),
@@ -130,7 +130,7 @@ void
 PB_DS_CLASS_C_DEC::
 value_swap(PB_DS_CLASS_C_DEC& other)
 {
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::swap(other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::swap(other);)
   std::swap(m_p_head, other.m_p_head);
   std::swap(m_size, other.m_size);
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp
index a2253a6a502..d0cef7a3a6e 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp
@@ -77,7 +77,7 @@ assert_iterators() const
   for (const_iterator it = begin(); it != end(); ++it)
     {
       ++calc_size;
-      map_debug_base::check_key_exists(PB_DS_V2F(*it));
+      debug_base::check_key_exists(PB_DS_V2F(*it));
       _GLIBCXX_DEBUG_ASSERT(lower_bound(PB_DS_V2F(*it)) == it);
       _GLIBCXX_DEBUG_ASSERT(--upper_bound(PB_DS_V2F(*it)) == it);
     }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp
index 0fba3a4e285..42bb032701d 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp
@@ -52,18 +52,18 @@ erase(const_key_reference r_key)
   node_pointer p_nd = find_imp(r_key);
   if (p_nd == NULL || p_nd->m_type == pat_trie_internal_node_type)
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key));
       return false;
     }
 
   _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == pat_trie_leaf_node_type);
   if (!synth_e_access_traits::equal_keys(PB_DS_V2F(reinterpret_cast<leaf_pointer>(p_nd)->value()), r_key))
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key));
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key));
       return false;
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key));
   erase_leaf(static_cast<leaf_pointer>(p_nd));
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   return true;
@@ -141,7 +141,7 @@ clear()
   clear_imp(m_p_head->m_p_parent);
   m_size = 0;
   initialize();
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::clear();)
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp
index d9b3c4a9418..7a925e6a02b 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp
@@ -54,17 +54,17 @@ find(const_key_reference r_key)
 
   if (p_nd == NULL || p_nd->m_type != pat_trie_leaf_node_type)
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
       return end();
     }
 
   if (synth_e_access_traits::equal_keys(PB_DS_V2F(static_cast<leaf_pointer>(p_nd)->value()), r_key))
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key));
       return iterator(p_nd);
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
   return end();
 }
 
@@ -79,17 +79,17 @@ find(const_key_reference r_key) const
 
   if (p_nd == NULL || p_nd->m_type != pat_trie_leaf_node_type)
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
       return end();
     }
 
   if (synth_e_access_traits::equal_keys(PB_DS_V2F(static_cast<const_leaf_pointer>(p_nd)->value()), r_key))
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key));
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key));
       return const_iterator(const_cast<node_pointer>(p_nd));
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(r_key);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);)
   return end();
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp
index 4916ae34ff6..ff4dd601038 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp
@@ -98,7 +98,7 @@ join_prep(PB_DS_CLASS_C_DEC& other, split_join_branch_bag& r_bag)
     __throw_join_error();
 
   rec_join_prep(m_p_head->m_p_parent, other.m_p_head->m_p_parent, r_bag);
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::join(other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::join(other);)
   return true;
 }
 
@@ -387,12 +387,12 @@ insert(const_reference r_val)
   if (p_lf != NULL && p_lf->m_type == pat_trie_leaf_node_type && 
       synth_e_access_traits::equal_keys(PB_DS_V2F(static_cast<leaf_pointer>(p_lf)->value()), PB_DS_V2F(r_val)))
     {
-      _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(PB_DS_V2F(r_val)));
+      _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(PB_DS_V2F(r_val)));
       _GLIBCXX_DEBUG_ONLY(assert_valid();)
       return std::make_pair(iterator(p_lf), false);
     }
 
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_does_not_exist(PB_DS_V2F(r_val)));
+  _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(PB_DS_V2F(r_val)));
 
   leaf_pointer p_new_lf = s_leaf_allocator.allocate(1);
   cond_dealtor cond(p_new_lf);
@@ -407,7 +407,7 @@ insert(const_reference r_val)
   cond.set_no_action_dtor();
   ++m_size;
   update_min_max_for_inserted_leaf(p_new_lf);
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::insert_new(PB_DS_V2F(r_val));)   
+  _GLIBCXX_DEBUG_ONLY(debug_base::insert_new(PB_DS_V2F(r_val));)   
   _GLIBCXX_DEBUG_ONLY(assert_valid();)
   return std::make_pair(point_iterator(p_new_lf), true);
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_.hpp
index 18c1a79414e..386f91557db 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/pat_trie_.hpp
@@ -67,7 +67,7 @@
 #include <assert.h>
 #include <list>
 #ifdef _GLIBCXX_DEBUG
-#include <ext/pb_ds/detail/map_debug_base.hpp>
+#include <ext/pb_ds/detail/debug_map_base.hpp>
 #endif 
 #include <debug/debug.h>
 
@@ -94,8 +94,8 @@ namespace pb_ds
     types_traits<Key, Mapped, Allocator, false>
 
 #ifdef _GLIBCXX_DEBUG
-#define PB_DS_MAP_DEBUG_BASE_C_DEC \
-    map_debug_base<Key,	eq_by_less<Key, \
+#define PB_DS_DEBUG_MAP_BASE_C_DEC \
+    debug_map_base<Key,	eq_by_less<Key, \
 			std::less<Key> >, typename Allocator::template rebind<Key>::other::const_reference>
 #endif 
 
@@ -120,7 +120,7 @@ namespace pb_ds
 	     typename Allocator>
     class PB_DS_CLASS_NAME :
 #ifdef _GLIBCXX_DEBUG
-      public PB_DS_MAP_DEBUG_BASE_C_DEC,
+      public PB_DS_DEBUG_MAP_BASE_C_DEC,
 #endif 
       public Node_And_It_Traits::synth_e_access_traits,
       public Node_And_It_Traits::node_update,
@@ -155,7 +155,7 @@ namespace pb_ds
 #include <ext/pb_ds/detail/pat_trie_/cond_dtor_entry_dealtor.hpp>
 
 #ifdef _GLIBCXX_DEBUG
-      typedef PB_DS_MAP_DEBUG_BASE_C_DEC map_debug_base;
+      typedef PB_DS_DEBUG_MAP_BASE_C_DEC debug_base;
 #endif 
 
 #include <ext/pb_ds/detail/pat_trie_/split_join_branch_bag.hpp>
@@ -512,7 +512,7 @@ namespace pb_ds
 #undef PB_DS_CLASS_T_DEC
 #undef PB_DS_CLASS_NAME
 #undef PB_DS_TYPES_TRAITS_C_DEC
-#undef PB_DS_MAP_DEBUG_BASE_C_DEC
+#undef PB_DS_DEBUG_MAP_BASE_C_DEC
 #undef PB_DS_V2F
 #undef PB_DS_EP2VP
 #undef PB_DS_V2S
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp
index 63553ec92a4..a119a5e8f16 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp
@@ -90,7 +90,7 @@ clear()
   clear_imp(m_p_head->m_p_parent);
   m_size = 0;
   initialize();
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::clear();)
+  _GLIBCXX_DEBUG_ONLY(debug_base::clear();)
   _GLIBCXX_DEBUG_ONLY(assert_valid(true, true);)
 }
 
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp
index ed5d890f6f2..efe96498257 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp
@@ -128,7 +128,7 @@ split_prep(const_key_reference r_key, PB_DS_CLASS_C_DEC& other, split_join_branc
       r_bag.add_branch();
       p_nd = p_nd->m_p_parent;
     }
-  _GLIBCXX_DEBUG_ONLY(map_debug_base::split(r_key,(synth_e_access_traits& )(*this), other);)
+  _GLIBCXX_DEBUG_ONLY(debug_base::split(r_key,(synth_e_access_traits& )(*this), other);)
 
   return (p_ret_l);
 }
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp
index 9c6737515cb..8be9245110a 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp
@@ -175,7 +175,7 @@ notify_externally_resized(size_type new_size)
 {
   m_resize_needed = false;
   size_type new_grow_size = size_type(m_load_max * new_size - 1);
-  size_type new_shrink_size = size_type(m_load_min * new_size );
+  size_type new_shrink_size = size_type(m_load_min * new_size);
   if (new_grow_size >= m_next_grow_size)
     {
       _GLIBCXX_DEBUG_ASSERT(new_shrink_size > m_next_shrink_size);
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp b/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp
index 8272c8a71a4..089ca062f27 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/types_traits.hpp
@@ -74,10 +74,13 @@ namespace pb_ds
       typedef typename Alloc::size_type size_type;
 
       // Extra value (used when the extra value is stored with each value).
-      typedef std::pair<size_type, size_type> comp_hash;
+      typedef std::pair<size_type, size_type> 	comp_hash;
 
-      integral_constant<int, Store_Extra> m_store_extra_indicator;
-      typename no_throw_copies<Key, Mapped>::indicator m_no_throw_copies_indicator;
+      typedef integral_constant<int, Store_Extra> store_extra;
+      store_extra	m_store_extra_indicator;
+
+      typedef typename no_throw_copies<Key, Mapped>::indicator no_throw_copies;
+      no_throw_copies 	m_no_throw_copies_indicator;
     };
   } // namespace detail
 } // namespace pb_ds
diff --git a/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp b/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp
index 94039af0d80..74181b1fb9e 100644
--- a/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp
@@ -50,6 +50,11 @@
 
 #include <ext/pb_ds/detail/type_utils.hpp>
 
+/**
+ * @namespace pb_ds
+ * @brief GNU extension policy-based data structures for public use.
+ */
+
 namespace pb_ds
 {
   // A trivial iterator tag. Signifies that the iterators has none of