--- a/memory/build/mozjemalloc.cpp
+++ b/memory/build/mozjemalloc.cpp
@@ -1513,30 +1513,30 @@ extent_szad_comp(extent_node_t *a, exten
 
 		ret = (a_addr > b_addr) - (a_addr < b_addr);
 	}
 
 	return (ret);
 }
 
 /* Wrap red-black tree macros in functions. */
-rb_wrap(static, extent_tree_szad_, extent_tree_t, extent_node_t,
+rb_wrap(extent_tree_szad_, extent_tree_t, extent_node_t,
     link_szad, extent_szad_comp)
 
 static inline int
 extent_ad_comp(extent_node_t *a, extent_node_t *b)
 {
 	uintptr_t a_addr = (uintptr_t)a->addr;
 	uintptr_t b_addr = (uintptr_t)b->addr;
 
 	return ((a_addr > b_addr) - (a_addr < b_addr));
 }
 
 /* Wrap red-black tree macros in functions. */
-rb_wrap(static, extent_tree_ad_, extent_tree_t, extent_node_t, link_ad,
+rb_wrap(extent_tree_ad_, extent_tree_t, extent_node_t, link_ad,
     extent_ad_comp)
 
 static inline int
 extent_bounds_comp(extent_node_t* aKey, extent_node_t* aNode)
 {
   uintptr_t key_addr = (uintptr_t)aKey->addr;
   uintptr_t node_addr = (uintptr_t)aNode->addr;
   size_t node_size = aNode->size;
@@ -2373,48 +2373,48 @@ arena_comp(arena_t* a, arena_t* b)
 {
   MOZ_ASSERT(a);
   MOZ_ASSERT(b);
 
   return (a->mId > b->mId) - (a->mId < b->mId);
 }
 
 /* Wrap red-black tree macros in functions. */
-rb_wrap(static, arena_tree_, arena_tree_t, arena_t, mLink, arena_comp)
+rb_wrap(arena_tree_, arena_tree_t, arena_t, mLink, arena_comp)
 
 static inline int
 arena_chunk_comp(arena_chunk_t *a, arena_chunk_t *b)
 {
 	uintptr_t a_chunk = (uintptr_t)a;
 	uintptr_t b_chunk = (uintptr_t)b;
 
 	MOZ_ASSERT(a);
 	MOZ_ASSERT(b);
 
 	return ((a_chunk > b_chunk) - (a_chunk < b_chunk));
 }
 
 /* Wrap red-black tree macros in functions. */
-rb_wrap(static, arena_chunk_tree_dirty_, arena_chunk_tree_t,
+rb_wrap(arena_chunk_tree_dirty_, arena_chunk_tree_t,
     arena_chunk_t, link_dirty, arena_chunk_comp)
 
 static inline int
 arena_run_comp(arena_chunk_map_t *a, arena_chunk_map_t *b)
 {
 	uintptr_t a_mapelm = (uintptr_t)a;
 	uintptr_t b_mapelm = (uintptr_t)b;
 
 	MOZ_ASSERT(a);
 	MOZ_ASSERT(b);
 
 	return ((a_mapelm > b_mapelm) - (a_mapelm < b_mapelm));
 }
 
 /* Wrap red-black tree macros in functions. */
-rb_wrap(static, arena_run_tree_, arena_run_tree_t, arena_chunk_map_t, link,
+rb_wrap(arena_run_tree_, arena_run_tree_t, arena_chunk_map_t, link,
     arena_run_comp)
 
 static inline int
 arena_avail_comp(arena_chunk_map_t *a, arena_chunk_map_t *b)
 {
 	int ret;
 	size_t a_size = a->bits & ~pagesize_mask;
 	size_t b_size = b->bits & ~pagesize_mask;
@@ -2436,17 +2436,17 @@ arena_avail_comp(arena_chunk_map_t *a, a
 
 		ret = (a_mapelm > b_mapelm) - (a_mapelm < b_mapelm);
 	}
 
 	return (ret);
 }
 
 /* Wrap red-black tree macros in functions. */
-rb_wrap(static, arena_avail_tree_, arena_avail_tree_t, arena_chunk_map_t, link,
+rb_wrap(arena_avail_tree_, arena_avail_tree_t, arena_chunk_map_t, link,
     arena_avail_comp)
 
 static inline void *
 arena_run_reg_alloc(arena_run_t *run, arena_bin_t *bin)
 {
 	void *ret;
 	unsigned i, mask, bit, regind;
 

--- a/memory/build/rb.h
+++ b/memory/build/rb.h
@@ -701,62 +701,62 @@ struct RedBlackTree
 /*
  * The rb_wrap() macro provides a convenient way to wrap functions around the
  * cpp macros.  The main benefits of wrapping are that 1) repeated macro
  * expansion can cause code bloat, especially for rb_{insert,remove)(), and
  * 2) type, linkage, comparison functions, etc. need not be specified at every
  * call point.
  */
 
-#define	rb_wrap(a_attr, a_prefix, a_tree_type, a_type, a_field, a_cmp)	\
-a_attr void								\
+#define	rb_wrap(a_prefix, a_tree_type, a_type, a_field, a_cmp)		\
+static void								\
 a_prefix##new(a_tree_type *tree) {					\
     rb_new(a_type, a_field, tree);					\
 }									\
-a_attr a_type *								\
+static a_type *								\
 a_prefix##first(a_tree_type *tree) {					\
     a_type *ret;							\
     rb_first(a_type, a_field, tree, ret);				\
     return (ret);							\
 }									\
-a_attr a_type *								\
+static a_type *								\
 a_prefix##last(a_tree_type *tree) {					\
     a_type *ret;							\
     rb_last(a_type, a_field, tree, ret);				\
     return (ret);							\
 }									\
-a_attr a_type *								\
+static a_type *								\
 a_prefix##next(a_tree_type *tree, a_type *node) {			\
     a_type *ret;							\
     rb_next(a_type, a_field, a_cmp, tree, node, ret);			\
     return (ret);							\
 }									\
-a_attr a_type *								\
+static a_type *								\
 a_prefix##prev(a_tree_type *tree, a_type *node) {			\
     a_type *ret;							\
     rb_prev(a_type, a_field, a_cmp, tree, node, ret);			\
     return (ret);							\
 }									\
-a_attr a_type *								\
+static a_type *								\
 a_prefix##search(a_tree_type *tree, a_type *key) {			\
     a_type *ret;							\
     rb_search(a_type, a_field, a_cmp, tree, key, ret);			\
     return (ret);							\
 }									\
-a_attr a_type *								\
+static a_type *								\
 a_prefix##nsearch(a_tree_type *tree, a_type *key) {			\
     a_type *ret;							\
     rb_nsearch(a_type, a_field, a_cmp, tree, key, ret);			\
     return (ret);							\
 }									\
-a_attr void								\
+static void								\
 a_prefix##insert(a_tree_type *tree, a_type *node) {			\
     rb_insert(a_type, a_field, a_cmp, tree, node);			\
 }									\
-a_attr void								\
+static void								\
 a_prefix##remove(a_tree_type *tree, a_type *node) {			\
     rb_remove(a_type, a_field, a_cmp, tree, node);			\
 }
 
 /*
  * The iterators simulate recursion via an array of pointers that store the
  * current path.  This is critical to performance, since a series of calls to
  * rb_{next,prev}() would require time proportional to (n lg n), whereas this