Reduce cpp conditional logic complexity.

Convert configuration-related cpp conditional logic to use static
constant variables, e.g.:

  #ifdef JEMALLOC_DEBUG
    [...]
  #endif

becomes:

  if (config_debug) {
    [...]
  }

The advantage is clearer, more concise code.  The main disadvantage is
that data structures no longer have conditionally defined fields, so
they pay the cost of all fields regardless of whether they are used.  In
practice, this is only a minor concern; config_stats will go away in an
upcoming change, and config_prof is the only other major feature that
depends on more than a few special-purpose fields.

1 files changed, 231 insertions, 367 deletions

diff --git a/src/ctl.c b/src/ctl.c
index e5336d3..05be431 100644
--- a/src/ctl.c
+++ b/src/ctl.c
@@ -27,16 +27,12 @@ static int	n##_ctl(const size_t *mib, size_t miblen, void *oldp,	\
 const ctl_node_t	*n##_index(const size_t *mib, size_t miblen,	\
     size_t i);
 
-#ifdef JEMALLOC_STATS
 static bool	ctl_arena_init(ctl_arena_stats_t *astats);
-#endif
 static void	ctl_arena_clear(ctl_arena_stats_t *astats);
-#ifdef JEMALLOC_STATS
 static void	ctl_arena_stats_amerge(ctl_arena_stats_t *cstats,
     arena_t *arena);
 static void	ctl_arena_stats_smerge(ctl_arena_stats_t *sstats,
     ctl_arena_stats_t *astats);
-#endif
 static void	ctl_arena_refresh(arena_t *arena, unsigned i);
 static void	ctl_refresh(void);
 static bool	ctl_init(void);
@@ -45,16 +41,12 @@ static int	ctl_lookup(const char *name, ctl_node_t const **nodesp,
 
 CTL_PROTO(version)
 CTL_PROTO(epoch)
-#ifdef JEMALLOC_TCACHE
 CTL_PROTO(tcache_flush)
-#endif
 CTL_PROTO(thread_arena)
-#ifdef JEMALLOC_STATS
 CTL_PROTO(thread_allocated)
 CTL_PROTO(thread_allocatedp)
 CTL_PROTO(thread_deallocated)
 CTL_PROTO(thread_deallocatedp)
-#endif
 CTL_PROTO(config_debug)
 CTL_PROTO(config_dss)
 CTL_PROTO(config_dynamic_page_shift)
@@ -77,21 +69,12 @@ CTL_PROTO(opt_lg_chunk)
 CTL_PROTO(opt_narenas)
 CTL_PROTO(opt_lg_dirty_mult)
 CTL_PROTO(opt_stats_print)
-#ifdef JEMALLOC_FILL
 CTL_PROTO(opt_junk)
 CTL_PROTO(opt_zero)
-#endif
-#ifdef JEMALLOC_SYSV
 CTL_PROTO(opt_sysv)
-#endif
-#ifdef JEMALLOC_XMALLOC
 CTL_PROTO(opt_xmalloc)
-#endif
-#ifdef JEMALLOC_TCACHE
 CTL_PROTO(opt_tcache)
 CTL_PROTO(opt_lg_tcache_gc_sweep)
-#endif
-#ifdef JEMALLOC_PROF
 CTL_PROTO(opt_prof)
 CTL_PROTO(opt_prof_prefix)
 CTL_PROTO(opt_prof_active)
@@ -102,10 +85,7 @@ CTL_PROTO(opt_prof_gdump)
 CTL_PROTO(opt_prof_leak)
 CTL_PROTO(opt_prof_accum)
 CTL_PROTO(opt_lg_prof_tcmax)
-#endif
-#ifdef JEMALLOC_SWAP
 CTL_PROTO(opt_overcommit)
-#endif
 CTL_PROTO(arenas_bin_i_size)
 CTL_PROTO(arenas_bin_i_nregs)
 CTL_PROTO(arenas_bin_i_run_size)
@@ -119,35 +99,26 @@ CTL_PROTO(arenas_cacheline)
 CTL_PROTO(arenas_subpage)
 CTL_PROTO(arenas_pagesize)
 CTL_PROTO(arenas_chunksize)
-#ifdef JEMALLOC_TINY
 CTL_PROTO(arenas_tspace_min)
 CTL_PROTO(arenas_tspace_max)
-#endif
 CTL_PROTO(arenas_qspace_min)
 CTL_PROTO(arenas_qspace_max)
 CTL_PROTO(arenas_cspace_min)
 CTL_PROTO(arenas_cspace_max)
 CTL_PROTO(arenas_sspace_min)
 CTL_PROTO(arenas_sspace_max)
-#ifdef JEMALLOC_TCACHE
 CTL_PROTO(arenas_tcache_max)
-#endif
 CTL_PROTO(arenas_ntbins)
 CTL_PROTO(arenas_nqbins)
 CTL_PROTO(arenas_ncbins)
 CTL_PROTO(arenas_nsbins)
 CTL_PROTO(arenas_nbins)
-#ifdef JEMALLOC_TCACHE
 CTL_PROTO(arenas_nhbins)
-#endif
 CTL_PROTO(arenas_nlruns)
 CTL_PROTO(arenas_purge)
-#ifdef JEMALLOC_PROF
 CTL_PROTO(prof_active)
 CTL_PROTO(prof_dump)
 CTL_PROTO(prof_interval)
-#endif
-#ifdef JEMALLOC_STATS
 CTL_PROTO(stats_chunks_current)
 CTL_PROTO(stats_chunks_total)
 CTL_PROTO(stats_chunks_high)
@@ -166,10 +137,8 @@ CTL_PROTO(stats_arenas_i_bins_j_allocated)
 CTL_PROTO(stats_arenas_i_bins_j_nmalloc)
 CTL_PROTO(stats_arenas_i_bins_j_ndalloc)
 CTL_PROTO(stats_arenas_i_bins_j_nrequests)
-#ifdef JEMALLOC_TCACHE
 CTL_PROTO(stats_arenas_i_bins_j_nfills)
 CTL_PROTO(stats_arenas_i_bins_j_nflushes)
-#endif
 CTL_PROTO(stats_arenas_i_bins_j_nruns)
 CTL_PROTO(stats_arenas_i_bins_j_nreruns)
 CTL_PROTO(stats_arenas_i_bins_j_highruns)
@@ -181,31 +150,22 @@ CTL_PROTO(stats_arenas_i_lruns_j_nrequests)
 CTL_PROTO(stats_arenas_i_lruns_j_highruns)
 CTL_PROTO(stats_arenas_i_lruns_j_curruns)
 INDEX_PROTO(stats_arenas_i_lruns_j)
-#endif
 CTL_PROTO(stats_arenas_i_nthreads)
 CTL_PROTO(stats_arenas_i_pactive)
 CTL_PROTO(stats_arenas_i_pdirty)
-#ifdef JEMALLOC_STATS
 CTL_PROTO(stats_arenas_i_mapped)
 CTL_PROTO(stats_arenas_i_npurge)
 CTL_PROTO(stats_arenas_i_nmadvise)
 CTL_PROTO(stats_arenas_i_purged)
-#endif
 INDEX_PROTO(stats_arenas_i)
-#ifdef JEMALLOC_STATS
 CTL_PROTO(stats_cactive)
 CTL_PROTO(stats_allocated)
 CTL_PROTO(stats_active)
 CTL_PROTO(stats_mapped)
-#endif
-#ifdef JEMALLOC_SWAP
-#  ifdef JEMALLOC_STATS
 CTL_PROTO(swap_avail)
-#  endif
 CTL_PROTO(swap_prezeroed)
 CTL_PROTO(swap_nfds)
 CTL_PROTO(swap_fds)
-#endif
 
 /******************************************************************************/
 /* mallctl tree. */
@@ -223,21 +183,16 @@ CTL_PROTO(swap_fds)
  */
 #define	INDEX(i)	false,	{.indexed = {i##_index}},		NULL
 
-#ifdef JEMALLOC_TCACHE
 static const ctl_node_t	tcache_node[] = {
 	{NAME("flush"),		CTL(tcache_flush)}
 };
-#endif
 
 static const ctl_node_t	thread_node[] = {
-	{NAME("arena"),		CTL(thread_arena)}
-#ifdef JEMALLOC_STATS
-	,
+	{NAME("arena"),		CTL(thread_arena)},
 	{NAME("allocated"),	CTL(thread_allocated)},
 	{NAME("allocatedp"),	CTL(thread_allocatedp)},
 	{NAME("deallocated"),	CTL(thread_deallocated)},
 	{NAME("deallocatedp"),	CTL(thread_deallocatedp)}
-#endif
 };
 
 static const ctl_node_t	config_node[] = {
@@ -265,27 +220,13 @@ static const ctl_node_t opt_node[] = {
 	{NAME("lg_chunk"),		CTL(opt_lg_chunk)},
 	{NAME("narenas"),		CTL(opt_narenas)},
 	{NAME("lg_dirty_mult"),		CTL(opt_lg_dirty_mult)},
-	{NAME("stats_print"),		CTL(opt_stats_print)}
-#ifdef JEMALLOC_FILL
-	,
+	{NAME("stats_print"),		CTL(opt_stats_print)},
 	{NAME("junk"),			CTL(opt_junk)},
-	{NAME("zero"),			CTL(opt_zero)}
-#endif
-#ifdef JEMALLOC_SYSV
-	,
-	{NAME("sysv"),			CTL(opt_sysv)}
-#endif
-#ifdef JEMALLOC_XMALLOC
-	,
-	{NAME("xmalloc"),		CTL(opt_xmalloc)}
-#endif
-#ifdef JEMALLOC_TCACHE
-	,
+	{NAME("zero"),			CTL(opt_zero)},
+	{NAME("sysv"),			CTL(opt_sysv)},
+	{NAME("xmalloc"),		CTL(opt_xmalloc)},
 	{NAME("tcache"),		CTL(opt_tcache)},
-	{NAME("lg_tcache_gc_sweep"),	CTL(opt_lg_tcache_gc_sweep)}
-#endif
-#ifdef JEMALLOC_PROF
-	,
+	{NAME("lg_tcache_gc_sweep"),	CTL(opt_lg_tcache_gc_sweep)},
 	{NAME("prof"),			CTL(opt_prof)},
 	{NAME("prof_prefix"),		CTL(opt_prof_prefix)},
 	{NAME("prof_active"),		CTL(opt_prof_active)},
@@ -295,12 +236,8 @@ static const ctl_node_t opt_node[] = {
 	{NAME("prof_gdump"),		CTL(opt_prof_gdump)},
 	{NAME("prof_leak"),		CTL(opt_prof_leak)},
 	{NAME("prof_accum"),		CTL(opt_prof_accum)},
-	{NAME("lg_prof_tcmax"),		CTL(opt_lg_prof_tcmax)}
-#endif
-#ifdef JEMALLOC_SWAP
-	,
+	{NAME("lg_prof_tcmax"),		CTL(opt_lg_prof_tcmax)},
 	{NAME("overcommit"),		CTL(opt_overcommit)}
-#endif
 };
 
 static const ctl_node_t arenas_bin_i_node[] = {
@@ -335,42 +272,33 @@ static const ctl_node_t arenas_node[] = {
 	{NAME("subpage"),		CTL(arenas_subpage)},
 	{NAME("pagesize"),		CTL(arenas_pagesize)},
 	{NAME("chunksize"),		CTL(arenas_chunksize)},
-#ifdef JEMALLOC_TINY
 	{NAME("tspace_min"),		CTL(arenas_tspace_min)},
 	{NAME("tspace_max"),		CTL(arenas_tspace_max)},
-#endif
 	{NAME("qspace_min"),		CTL(arenas_qspace_min)},
 	{NAME("qspace_max"),		CTL(arenas_qspace_max)},
 	{NAME("cspace_min"),		CTL(arenas_cspace_min)},
 	{NAME("cspace_max"),		CTL(arenas_cspace_max)},
 	{NAME("sspace_min"),		CTL(arenas_sspace_min)},
 	{NAME("sspace_max"),		CTL(arenas_sspace_max)},
-#ifdef JEMALLOC_TCACHE
 	{NAME("tcache_max"),		CTL(arenas_tcache_max)},
-#endif
 	{NAME("ntbins"),		CTL(arenas_ntbins)},
 	{NAME("nqbins"),		CTL(arenas_nqbins)},
 	{NAME("ncbins"),		CTL(arenas_ncbins)},
 	{NAME("nsbins"),		CTL(arenas_nsbins)},
 	{NAME("nbins"),			CTL(arenas_nbins)},
-#ifdef JEMALLOC_TCACHE
 	{NAME("nhbins"),		CTL(arenas_nhbins)},
-#endif
 	{NAME("bin"),			CHILD(arenas_bin)},
 	{NAME("nlruns"),		CTL(arenas_nlruns)},
 	{NAME("lrun"),			CHILD(arenas_lrun)},
 	{NAME("purge"),			CTL(arenas_purge)}
 };
 
-#ifdef JEMALLOC_PROF
 static const ctl_node_t	prof_node[] = {
 	{NAME("active"),	CTL(prof_active)},
 	{NAME("dump"),		CTL(prof_dump)},
 	{NAME("interval"),	CTL(prof_interval)}
 };
-#endif
 
-#ifdef JEMALLOC_STATS
 static const ctl_node_t stats_chunks_node[] = {
 	{NAME("current"),		CTL(stats_chunks_current)},
 	{NAME("total"),			CTL(stats_chunks_total)},
@@ -402,10 +330,8 @@ static const ctl_node_t stats_arenas_i_bins_j_node[] = {
 	{NAME("nmalloc"),		CTL(stats_arenas_i_bins_j_nmalloc)},
 	{NAME("ndalloc"),		CTL(stats_arenas_i_bins_j_ndalloc)},
 	{NAME("nrequests"),		CTL(stats_arenas_i_bins_j_nrequests)},
-#ifdef JEMALLOC_TCACHE
 	{NAME("nfills"),		CTL(stats_arenas_i_bins_j_nfills)},
 	{NAME("nflushes"),		CTL(stats_arenas_i_bins_j_nflushes)},
-#endif
 	{NAME("nruns"),			CTL(stats_arenas_i_bins_j_nruns)},
 	{NAME("nreruns"),		CTL(stats_arenas_i_bins_j_nreruns)},
 	{NAME("highruns"),		CTL(stats_arenas_i_bins_j_highruns)},
@@ -433,14 +359,11 @@ static const ctl_node_t super_stats_arenas_i_lruns_j_node[] = {
 static const ctl_node_t stats_arenas_i_lruns_node[] = {
 	{INDEX(stats_arenas_i_lruns_j)}
 };
-#endif
 
 static const ctl_node_t stats_arenas_i_node[] = {
 	{NAME("nthreads"),		CTL(stats_arenas_i_nthreads)},
 	{NAME("pactive"),		CTL(stats_arenas_i_pactive)},
-	{NAME("pdirty"),		CTL(stats_arenas_i_pdirty)}
-#ifdef JEMALLOC_STATS
-	,
+	{NAME("pdirty"),		CTL(stats_arenas_i_pdirty)},
 	{NAME("mapped"),		CTL(stats_arenas_i_mapped)},
 	{NAME("npurge"),		CTL(stats_arenas_i_npurge)},
 	{NAME("nmadvise"),		CTL(stats_arenas_i_nmadvise)},
@@ -449,7 +372,6 @@ static const ctl_node_t stats_arenas_i_node[] = {
 	{NAME("large"),			CHILD(stats_arenas_i_large)},
 	{NAME("bins"),			CHILD(stats_arenas_i_bins)},
 	{NAME("lruns"),		CHILD(stats_arenas_i_lruns)}
-#endif
 };
 static const ctl_node_t super_stats_arenas_i_node[] = {
 	{NAME(""),			CHILD(stats_arenas_i)}
@@ -460,46 +382,34 @@ static const ctl_node_t stats_arenas_node[] = {
 };
 
 static const ctl_node_t stats_node[] = {
-#ifdef JEMALLOC_STATS
 	{NAME("cactive"),		CTL(stats_cactive)},
 	{NAME("allocated"),		CTL(stats_allocated)},
 	{NAME("active"),		CTL(stats_active)},
 	{NAME("mapped"),		CTL(stats_mapped)},
 	{NAME("chunks"),		CHILD(stats_chunks)},
 	{NAME("huge"),			CHILD(stats_huge)},
-#endif
 	{NAME("arenas"),		CHILD(stats_arenas)}
 };
 
-#ifdef JEMALLOC_SWAP
 static const ctl_node_t swap_node[] = {
-#  ifdef JEMALLOC_STATS
 	{NAME("avail"),			CTL(swap_avail)},
-#  endif
 	{NAME("prezeroed"),		CTL(swap_prezeroed)},
 	{NAME("nfds"),			CTL(swap_nfds)},
 	{NAME("fds"),			CTL(swap_fds)}
 };
-#endif
 
 static const ctl_node_t	root_node[] = {
 	{NAME("version"),	CTL(version)},
 	{NAME("epoch"),		CTL(epoch)},
-#ifdef JEMALLOC_TCACHE
 	{NAME("tcache"),	CHILD(tcache)},
-#endif
 	{NAME("thread"),	CHILD(thread)},
 	{NAME("config"),	CHILD(config)},
 	{NAME("opt"),		CHILD(opt)},
 	{NAME("arenas"),	CHILD(arenas)},
-#ifdef JEMALLOC_PROF
 	{NAME("prof"),		CHILD(prof)},
-#endif
 	{NAME("stats"),		CHILD(stats)}
-#ifdef JEMALLOC_SWAP
 	,
 	{NAME("swap"),		CHILD(swap)}
-#endif
 };
 static const ctl_node_t super_root_node[] = {
 	{NAME(""),		CHILD(root)}
@@ -512,7 +422,6 @@ static const ctl_node_t super_root_node[] = {
 
 /******************************************************************************/
 
-#ifdef JEMALLOC_STATS
 static bool
 ctl_arena_init(ctl_arena_stats_t *astats)
 {
@@ -532,7 +441,6 @@ ctl_arena_init(ctl_arena_stats_t *astats)
 
 	return (false);
 }
-#endif
 
 static void
 ctl_arena_clear(ctl_arena_stats_t *astats)
@@ -540,18 +448,18 @@ ctl_arena_clear(ctl_arena_stats_t *astats)
 
 	astats->pactive = 0;
 	astats->pdirty = 0;
-#ifdef JEMALLOC_STATS
-	memset(&astats->astats, 0, sizeof(arena_stats_t));
-	astats->allocated_small = 0;
-	astats->nmalloc_small = 0;
-	astats->ndalloc_small = 0;
-	astats->nrequests_small = 0;
-	memset(astats->bstats, 0, nbins * sizeof(malloc_bin_stats_t));
-	memset(astats->lstats, 0, nlclasses * sizeof(malloc_large_stats_t));
-#endif
+	if (config_stats) {
+		memset(&astats->astats, 0, sizeof(arena_stats_t));
+		astats->allocated_small = 0;
+		astats->nmalloc_small = 0;
+		astats->ndalloc_small = 0;
+		astats->nrequests_small = 0;
+		memset(astats->bstats, 0, nbins * sizeof(malloc_bin_stats_t));
+		memset(astats->lstats, 0, nlclasses *
+		    sizeof(malloc_large_stats_t));
+	}
 }
 
-#ifdef JEMALLOC_STATS
 static void
 ctl_arena_stats_amerge(ctl_arena_stats_t *cstats, arena_t *arena)
 {
@@ -604,17 +512,17 @@ ctl_arena_stats_smerge(ctl_arena_stats_t *sstats, ctl_arena_stats_t *astats)
 		sstats->bstats[i].nmalloc += astats->bstats[i].nmalloc;
 		sstats->bstats[i].ndalloc += astats->bstats[i].ndalloc;
 		sstats->bstats[i].nrequests += astats->bstats[i].nrequests;
-#ifdef JEMALLOC_TCACHE
-		sstats->bstats[i].nfills += astats->bstats[i].nfills;
-		sstats->bstats[i].nflushes += astats->bstats[i].nflushes;
-#endif
+		if (config_tcache) {
+			sstats->bstats[i].nfills += astats->bstats[i].nfills;
+			sstats->bstats[i].nflushes +=
+			    astats->bstats[i].nflushes;
+		}
 		sstats->bstats[i].nruns += astats->bstats[i].nruns;
 		sstats->bstats[i].reruns += astats->bstats[i].reruns;
 		sstats->bstats[i].highruns += astats->bstats[i].highruns;
 		sstats->bstats[i].curruns += astats->bstats[i].curruns;
 	}
 }
-#endif
 
 static void
 ctl_arena_refresh(arena_t *arena, unsigned i)
@@ -625,17 +533,17 @@ ctl_arena_refresh(arena_t *arena, unsigned i)
 	ctl_arena_clear(astats);
 
 	sstats->nthreads += astats->nthreads;
-#ifdef JEMALLOC_STATS
-	ctl_arena_stats_amerge(astats, arena);
-	/* Merge into sum stats as well. */
-	ctl_arena_stats_smerge(sstats, astats);
-#else
-	astats->pactive += arena->nactive;
-	astats->pdirty += arena->ndirty;
-	/* Merge into sum stats as well. */
-	sstats->pactive += arena->nactive;
-	sstats->pdirty += arena->ndirty;
-#endif
+	if (config_stats) {
+		ctl_arena_stats_amerge(astats, arena);
+		/* Merge into sum stats as well. */
+		ctl_arena_stats_smerge(sstats, astats);
+	} else {
+		astats->pactive += arena->nactive;
+		astats->pdirty += arena->ndirty;
+		/* Merge into sum stats as well. */
+		sstats->pactive += arena->nactive;
+		sstats->pdirty += arena->ndirty;
+	}
 }
 
 static void
@@ -644,19 +552,19 @@ ctl_refresh(void)
 	unsigned i;
 	arena_t *tarenas[narenas];
 
-#ifdef JEMALLOC_STATS
-	malloc_mutex_lock(&chunks_mtx);
-	ctl_stats.chunks.current = stats_chunks.curchunks;
-	ctl_stats.chunks.total = stats_chunks.nchunks;
-	ctl_stats.chunks.high = stats_chunks.highchunks;
-	malloc_mutex_unlock(&chunks_mtx);
-
-	malloc_mutex_lock(&huge_mtx);
-	ctl_stats.huge.allocated = huge_allocated;
-	ctl_stats.huge.nmalloc = huge_nmalloc;
-	ctl_stats.huge.ndalloc = huge_ndalloc;
-	malloc_mutex_unlock(&huge_mtx);
-#endif
+	if (config_stats) {
+		malloc_mutex_lock(&chunks_mtx);
+		ctl_stats.chunks.current = stats_chunks.curchunks;
+		ctl_stats.chunks.total = stats_chunks.nchunks;
+		ctl_stats.chunks.high = stats_chunks.highchunks;
+		malloc_mutex_unlock(&chunks_mtx);
+
+		malloc_mutex_lock(&huge_mtx);
+		ctl_stats.huge.allocated = huge_allocated;
+		ctl_stats.huge.nmalloc = huge_nmalloc;
+		ctl_stats.huge.ndalloc = huge_ndalloc;
+		malloc_mutex_unlock(&huge_mtx);
+	}
 
 	/*
 	 * Clear sum stats, since they will be merged into by
@@ -682,20 +590,20 @@ ctl_refresh(void)
 			ctl_arena_refresh(tarenas[i], i);
 	}
 
-#ifdef JEMALLOC_STATS
-	ctl_stats.allocated = ctl_stats.arenas[narenas].allocated_small
-	    + ctl_stats.arenas[narenas].astats.allocated_large
-	    + ctl_stats.huge.allocated;
-	ctl_stats.active = (ctl_stats.arenas[narenas].pactive << PAGE_SHIFT)
-	    + ctl_stats.huge.allocated;
-	ctl_stats.mapped = (ctl_stats.chunks.current << opt_lg_chunk);
-
-#  ifdef JEMALLOC_SWAP
-	malloc_mutex_lock(&swap_mtx);
-	ctl_stats.swap_avail = swap_avail;
-	malloc_mutex_unlock(&swap_mtx);
-#  endif
-#endif
+	if (config_stats) {
+		ctl_stats.allocated = ctl_stats.arenas[narenas].allocated_small
+		    + ctl_stats.arenas[narenas].astats.allocated_large
+		    + ctl_stats.huge.allocated;
+		ctl_stats.active = (ctl_stats.arenas[narenas].pactive <<
+		    PAGE_SHIFT) + ctl_stats.huge.allocated;
+		ctl_stats.mapped = (ctl_stats.chunks.current << opt_lg_chunk);
+
+		if (config_swap) {
+			malloc_mutex_lock(&swap_mtx);
+			ctl_stats.swap_avail = swap_avail;
+			malloc_mutex_unlock(&swap_mtx);
+		}
+	}
 
 	ctl_epoch++;
 }
@@ -707,10 +615,6 @@ ctl_init(void)
 
 	malloc_mutex_lock(&ctl_mtx);
 	if (ctl_initialized == false) {
-#ifdef JEMALLOC_STATS
-		unsigned i;
-#endif
-
 		/*
 		 * Allocate space for one extra arena stats element, which
 		 * contains summed stats across all arenas.
@@ -729,14 +633,15 @@ ctl_init(void)
 		 * ever get used.  Lazy initialization would allow errors to
 		 * cause inconsistent state to be viewable by the application.
 		 */
-#ifdef JEMALLOC_STATS
-		for (i = 0; i <= narenas; i++) {
-			if (ctl_arena_init(&ctl_stats.arenas[i])) {
-				ret = true;
-				goto RETURN;
+		if (config_stats) {
+			unsigned i;
+			for (i = 0; i <= narenas; i++) {
+				if (ctl_arena_init(&ctl_stats.arenas[i])) {
+					ret = true;
+					goto RETURN;
+				}
 			}
 		}
-#endif
 		ctl_stats.arenas[narenas].initialized = true;
 
 		ctl_epoch = 0;
@@ -998,6 +903,54 @@ ctl_boot(void)
 	}								\
 } while (0)
 
+/*
+ * There's a lot of code duplication in the following macros due to limitations
+ * in how nested cpp macros are expanded.
+ */
+#define	CTL_RO_CLGEN(c, l, n, v, t)					\
+static int								\
+n##_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,	\
+    void *newp, size_t newlen)						\
+{									\
+	int ret;							\
+	t oldval;							\
+									\
+	if ((c) == false)						\
+		return (ENOENT);					\
+	if (l)								\
+		malloc_mutex_lock(&ctl_mtx);				\
+	READONLY();							\
+	oldval = v;							\
+	READ(oldval, t);						\
+									\
+	ret = 0;							\
+RETURN:									\
+	if (l)								\
+		malloc_mutex_unlock(&ctl_mtx);				\
+	return (ret);							\
+}
+
+#define	CTL_RO_CGEN(c, n, v, t)						\
+static int								\
+n##_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,	\
+    void *newp, size_t newlen)						\
+{									\
+	int ret;							\
+	t oldval;							\
+									\
+	if ((c) == false)						\
+		return (ENOENT);					\
+	malloc_mutex_lock(&ctl_mtx);					\
+	READONLY();							\
+	oldval = v;							\
+	READ(oldval, t);						\
+									\
+	ret = 0;							\
+RETURN:									\
+	malloc_mutex_unlock(&ctl_mtx);					\
+	return (ret);							\
+}
+
 #define	CTL_RO_GEN(n, v, t)						\
 static int								\
 n##_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,	\
@@ -1021,7 +974,7 @@ RETURN:									\
  * ctl_mtx is not acquired, under the assumption that no pertinent data will
  * mutate during the call.
  */
-#define	CTL_RO_NL_GEN(n, v, t)					\
+#define	CTL_RO_NL_CGEN(c, n, v, t)					\
 static int								\
 n##_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,	\
     void *newp, size_t newlen)						\
@@ -1029,6 +982,8 @@ n##_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,	\
 	int ret;							\
 	t oldval;							\
 									\
+	if ((c) == false)						\
+		return (ENOENT);					\
 	READONLY();							\
 	oldval = v;							\
 	READ(oldval, t);						\
@@ -1038,24 +993,24 @@ RETURN:									\
 	return (ret);							\
 }
 
-#define	CTL_RO_TRUE_GEN(n)						\
+#define	CTL_RO_NL_GEN(n, v, t)						\
 static int								\
 n##_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,	\
     void *newp, size_t newlen)						\
 {									\
 	int ret;							\
-	bool oldval;							\
+	t oldval;							\
 									\
 	READONLY();							\
-	oldval = true;							\
-	READ(oldval, bool);						\
+	oldval = v;							\
+	READ(oldval, t);						\
 									\
 	ret = 0;							\
 RETURN:									\
 	return (ret);							\
 }
 
-#define	CTL_RO_FALSE_GEN(n)						\
+#define	CTL_RO_BOOL_CONFIG_GEN(n)					\
 static int								\
 n##_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,	\
     void *newp, size_t newlen)						\
@@ -1063,8 +1018,10 @@ n##_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,	\
 	int ret;							\
 	bool oldval;							\
 									\
+	if (n == false)							\
+		return (ENOENT);					\
 	READONLY();							\
-	oldval = false;							\
+	oldval = n;							\
 	READ(oldval, bool);						\
 									\
 	ret = 0;							\
@@ -1094,7 +1051,6 @@ RETURN:
 	return (ret);
 }
 
-#ifdef JEMALLOC_TCACHE
 static int
 tcache_flush_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
     void *newp, size_t newlen)
@@ -1102,6 +1058,9 @@ tcache_flush_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
 	int ret;
 	tcache_t *tcache;
 
+	if (config_tcache == false)
+		return (ENOENT);
+
 	VOID();
 
 	tcache = TCACHE_GET();
@@ -1116,7 +1075,6 @@ tcache_flush_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
 RETURN:
 	return (ret);
 }
-#endif
 
 static int
 thread_arena_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
@@ -1151,13 +1109,11 @@ thread_arena_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
 
 		/* Set new arena association. */
 		ARENA_SET(arena);
-#ifdef JEMALLOC_TCACHE
-		{
+		if (config_tcache) {
 			tcache_t *tcache = TCACHE_GET();
 			if (tcache != NULL)
 				tcache->arena = arena;
 		}
-#endif
 	}
 
 	ret = 0;
@@ -1165,104 +1121,29 @@ RETURN:
 	return (ret);
 }
 
-#ifdef JEMALLOC_STATS
-CTL_RO_NL_GEN(thread_allocated, ALLOCATED_GET(), uint64_t);
-CTL_RO_NL_GEN(thread_allocatedp, ALLOCATEDP_GET(), uint64_t *);
-CTL_RO_NL_GEN(thread_deallocated, DEALLOCATED_GET(), uint64_t);
-CTL_RO_NL_GEN(thread_deallocatedp, DEALLOCATEDP_GET(), uint64_t *);
-#endif
+CTL_RO_NL_CGEN(config_stats, thread_allocated, ALLOCATED_GET(), uint64_t)
+CTL_RO_NL_CGEN(config_stats, thread_allocatedp, ALLOCATEDP_GET(), uint64_t *)
+CTL_RO_NL_CGEN(config_stats, thread_deallocated, DEALLOCATED_GET(), uint64_t)
+CTL_RO_NL_CGEN(config_stats, thread_deallocatedp, DEALLOCATEDP_GET(),
+    uint64_t *)
 
 /******************************************************************************/
 
-#ifdef JEMALLOC_DEBUG
-CTL_RO_TRUE_GEN(config_debug)
-#else
-CTL_RO_FALSE_GEN(config_debug)
-#endif
-
-#ifdef JEMALLOC_DSS
-CTL_RO_TRUE_GEN(config_dss)
-#else
-CTL_RO_FALSE_GEN(config_dss)
-#endif
-
-#ifdef JEMALLOC_DYNAMIC_PAGE_SHIFT
-CTL_RO_TRUE_GEN(config_dynamic_page_shift)
-#else
-CTL_RO_FALSE_GEN(config_dynamic_page_shift)
-#endif
-
-#ifdef JEMALLOC_FILL
-CTL_RO_TRUE_GEN(config_fill)
-#else
-CTL_RO_FALSE_GEN(config_fill)
-#endif
-
-#ifdef JEMALLOC_LAZY_LOCK
-CTL_RO_TRUE_GEN(config_lazy_lock)
-#else
-CTL_RO_FALSE_GEN(config_lazy_lock)
-#endif
-
-#ifdef JEMALLOC_PROF
-CTL_RO_TRUE_GEN(config_prof)
-#else
-CTL_RO_FALSE_GEN(config_prof)
-#endif
-
-#ifdef JEMALLOC_PROF_LIBGCC
-CTL_RO_TRUE_GEN(config_prof_libgcc)
-#else
-CTL_RO_FALSE_GEN(config_prof_libgcc)
-#endif
-
-#ifdef JEMALLOC_PROF_LIBUNWIND
-CTL_RO_TRUE_GEN(config_prof_libunwind)
-#else
-CTL_RO_FALSE_GEN(config_prof_libunwind)
-#endif
-
-#ifdef JEMALLOC_STATS
-CTL_RO_TRUE_GEN(config_stats)
-#else
-CTL_RO_FALSE_GEN(config_stats)
-#endif
-
-#ifdef JEMALLOC_SWAP
-CTL_RO_TRUE_GEN(config_swap)
-#else
-CTL_RO_FALSE_GEN(config_swap)
-#endif
-
-#ifdef JEMALLOC_SYSV
-CTL_RO_TRUE_GEN(config_sysv)
-#else
-CTL_RO_FALSE_GEN(config_sysv)
-#endif
-
-#ifdef JEMALLOC_TCACHE
-CTL_RO_TRUE_GEN(config_tcache)
-#else
-CTL_RO_FALSE_GEN(config_tcache)
-#endif
-
-#ifdef JEMALLOC_TINY
-CTL_RO_TRUE_GEN(config_tiny)
-#else
-CTL_RO_FALSE_GEN(config_tiny)
-#endif
-
-#ifdef JEMALLOC_TLS
-CTL_RO_TRUE_GEN(config_tls)
-#else
-CTL_RO_FALSE_GEN(config_tls)
-#endif
-
-#ifdef JEMALLOC_XMALLOC
-CTL_RO_TRUE_GEN(config_xmalloc)
-#else
-CTL_RO_FALSE_GEN(config_xmalloc)
-#endif
+CTL_RO_BOOL_CONFIG_GEN(config_debug)
+CTL_RO_BOOL_CONFIG_GEN(config_dss)
+CTL_RO_BOOL_CONFIG_GEN(config_dynamic_page_shift)
+CTL_RO_BOOL_CONFIG_GEN(config_fill)
+CTL_RO_BOOL_CONFIG_GEN(config_lazy_lock)
+CTL_RO_BOOL_CONFIG_GEN(config_prof)
+CTL_RO_BOOL_CONFIG_GEN(config_prof_libgcc)
+CTL_RO_BOOL_CONFIG_GEN(config_prof_libunwind)
+CTL_RO_BOOL_CONFIG_GEN(config_stats)
+CTL_RO_BOOL_CONFIG_GEN(config_swap)
+CTL_RO_BOOL_CONFIG_GEN(config_sysv)
+CTL_RO_BOOL_CONFIG_GEN(config_tcache)
+CTL_RO_BOOL_CONFIG_GEN(config_tiny)
+CTL_RO_BOOL_CONFIG_GEN(config_tls)
+CTL_RO_BOOL_CONFIG_GEN(config_xmalloc)
 
 /******************************************************************************/
 
@@ -1273,35 +1154,24 @@ CTL_RO_NL_GEN(opt_lg_chunk, opt_lg_chunk, size_t)
 CTL_RO_NL_GEN(opt_narenas, opt_narenas, size_t)
 CTL_RO_NL_GEN(opt_lg_dirty_mult, opt_lg_dirty_mult, ssize_t)
 CTL_RO_NL_GEN(opt_stats_print, opt_stats_print, bool)
-#ifdef JEMALLOC_FILL
-CTL_RO_NL_GEN(opt_junk, opt_junk, bool)
-CTL_RO_NL_GEN(opt_zero, opt_zero, bool)
-#endif
-#ifdef JEMALLOC_SYSV
-CTL_RO_NL_GEN(opt_sysv, opt_sysv, bool)
-#endif
-#ifdef JEMALLOC_XMALLOC
-CTL_RO_NL_GEN(opt_xmalloc, opt_xmalloc, bool)
-#endif
-#ifdef JEMALLOC_TCACHE
-CTL_RO_NL_GEN(opt_tcache, opt_tcache, bool)
-CTL_RO_NL_GEN(opt_lg_tcache_gc_sweep, opt_lg_tcache_gc_sweep, ssize_t)
-#endif
-#ifdef JEMALLOC_PROF
-CTL_RO_NL_GEN(opt_prof, opt_prof, bool)
-CTL_RO_NL_GEN(opt_prof_prefix, opt_prof_prefix, const char *)
-CTL_RO_GEN(opt_prof_active, opt_prof_active, bool) /* Mutable. */
-CTL_RO_NL_GEN(opt_lg_prof_bt_max, opt_lg_prof_bt_max, size_t)
-CTL_RO_NL_GEN(opt_lg_prof_sample, opt_lg_prof_sample, size_t)
-CTL_RO_NL_GEN(opt_lg_prof_interval, opt_lg_prof_interval, ssize_t)
-CTL_RO_NL_GEN(opt_prof_gdump, opt_prof_gdump, bool)
-CTL_RO_NL_GEN(opt_prof_leak, opt_prof_leak, bool)
-CTL_RO_NL_GEN(opt_prof_accum, opt_prof_accum, bool)
-CTL_RO_NL_GEN(opt_lg_prof_tcmax, opt_lg_prof_tcmax, ssize_t)
-#endif
-#ifdef JEMALLOC_SWAP
-CTL_RO_NL_GEN(opt_overcommit, opt_overcommit, bool)
-#endif
+CTL_RO_NL_CGEN(config_fill, opt_junk, opt_junk, bool)
+CTL_RO_NL_CGEN(config_fill, opt_zero, opt_zero, bool)
+CTL_RO_NL_CGEN(config_sysv, opt_sysv, opt_sysv, bool)
+CTL_RO_NL_CGEN(config_xmalloc, opt_xmalloc, opt_xmalloc, bool)
+CTL_RO_NL_CGEN(config_tcache, opt_tcache, opt_tcache, bool)
+CTL_RO_NL_CGEN(config_tcache, opt_lg_tcache_gc_sweep, opt_lg_tcache_gc_sweep,
+    ssize_t)
+CTL_RO_NL_CGEN(config_prof, opt_prof, opt_prof, bool)
+CTL_RO_NL_CGEN(config_prof, opt_prof_prefix, opt_prof_prefix, const char *)
+CTL_RO_CGEN(config_prof, opt_prof_active, opt_prof_active, bool) /* Mutable. */
+CTL_RO_NL_CGEN(config_prof, opt_lg_prof_bt_max, opt_lg_prof_bt_max, size_t)
+CTL_RO_NL_CGEN(config_prof, opt_lg_prof_sample, opt_lg_prof_sample, size_t)
+CTL_RO_NL_CGEN(config_prof, opt_lg_prof_interval, opt_lg_prof_interval, ssize_t)
+CTL_RO_NL_CGEN(config_prof, opt_prof_gdump, opt_prof_gdump, bool)
+CTL_RO_NL_CGEN(config_prof, opt_prof_leak, opt_prof_leak, bool)
+CTL_RO_NL_CGEN(config_prof, opt_prof_accum, opt_prof_accum, bool)
+CTL_RO_NL_CGEN(config_prof, opt_lg_prof_tcmax, opt_lg_prof_tcmax, ssize_t)
+CTL_RO_NL_CGEN(config_swap, opt_overcommit, opt_overcommit, bool)
 
 /******************************************************************************/
 
@@ -1360,27 +1230,21 @@ CTL_RO_NL_GEN(arenas_cacheline, CACHELINE, size_t)
 CTL_RO_NL_GEN(arenas_subpage, SUBPAGE, size_t)
 CTL_RO_NL_GEN(arenas_pagesize, PAGE_SIZE, size_t)
 CTL_RO_NL_GEN(arenas_chunksize, chunksize, size_t)
-#ifdef JEMALLOC_TINY
-CTL_RO_NL_GEN(arenas_tspace_min, (1U << LG_TINY_MIN), size_t)
-CTL_RO_NL_GEN(arenas_tspace_max, (qspace_min >> 1), size_t)
-#endif
+CTL_RO_NL_CGEN(config_tiny, arenas_tspace_min, (1U << LG_TINY_MIN), size_t)
+CTL_RO_NL_CGEN(config_tiny, arenas_tspace_max, (qspace_min >> 1), size_t)
 CTL_RO_NL_GEN(arenas_qspace_min, qspace_min, size_t)
 CTL_RO_NL_GEN(arenas_qspace_max, qspace_max, size_t)
 CTL_RO_NL_GEN(arenas_cspace_min, cspace_min, size_t)
 CTL_RO_NL_GEN(arenas_cspace_max, cspace_max, size_t)
 CTL_RO_NL_GEN(arenas_sspace_min, sspace_min, size_t)
 CTL_RO_NL_GEN(arenas_sspace_max, sspace_max, size_t)
-#ifdef JEMALLOC_TCACHE
-CTL_RO_NL_GEN(arenas_tcache_max, tcache_maxclass, size_t)
-#endif
+CTL_RO_NL_CGEN(config_tcache, arenas_tcache_max, tcache_maxclass, size_t)
 CTL_RO_NL_GEN(arenas_ntbins, ntbins, unsigned)
 CTL_RO_NL_GEN(arenas_nqbins, nqbins, unsigned)
 CTL_RO_NL_GEN(arenas_ncbins, ncbins, unsigned)
 CTL_RO_NL_GEN(arenas_nsbins, nsbins, unsigned)
 CTL_RO_NL_GEN(arenas_nbins, nbins, unsigned)
-#ifdef JEMALLOC_TCACHE
-CTL_RO_NL_GEN(arenas_nhbins, nhbins, unsigned)
-#endif
+CTL_RO_NL_CGEN(config_tcache, arenas_nhbins, nhbins, unsigned)
 CTL_RO_NL_GEN(arenas_nlruns, nlclasses, size_t)
 
 static int
@@ -1423,7 +1287,6 @@ RETURN:
 
 /******************************************************************************/
 
-#ifdef JEMALLOC_PROF
 static int
 prof_active_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
     void *newp, size_t newlen)
@@ -1431,6 +1294,9 @@ prof_active_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
 	int ret;
 	bool oldval;
 
+	if (config_prof == false)
+		return (ENOENT);
+
 	malloc_mutex_lock(&ctl_mtx); /* Protect opt_prof_active. */
 	oldval = opt_prof_active;
 	if (newp != NULL) {
@@ -1457,6 +1323,9 @@ prof_dump_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
 	int ret;
 	const char *filename = NULL;
 
+	if (config_prof == false)
+		return (ENOENT);
+
 	WRITEONLY();
 	WRITE(filename, const char *);
 
@@ -1470,56 +1339,53 @@ RETURN:
 	return (ret);
 }
 
-CTL_RO_NL_GEN(prof_interval, prof_interval, uint64_t)
-#endif
+CTL_RO_NL_CGEN(config_prof, prof_interval, prof_interval, uint64_t)
 
 /******************************************************************************/
 
-#ifdef JEMALLOC_STATS
-CTL_RO_GEN(stats_chunks_current, ctl_stats.chunks.current, size_t)
-CTL_RO_GEN(stats_chunks_total, ctl_stats.chunks.total, uint64_t)
-CTL_RO_GEN(stats_chunks_high, ctl_stats.chunks.high, size_t)
-CTL_RO_GEN(stats_huge_allocated, huge_allocated, size_t)
-CTL_RO_GEN(stats_huge_nmalloc, huge_nmalloc, uint64_t)
-CTL_RO_GEN(stats_huge_ndalloc, huge_ndalloc, uint64_t)
-CTL_RO_GEN(stats_arenas_i_small_allocated,
+CTL_RO_CGEN(config_stats, stats_chunks_current, ctl_stats.chunks.current,
+    size_t)
+CTL_RO_CGEN(config_stats, stats_chunks_total, ctl_stats.chunks.total, uint64_t)
+CTL_RO_CGEN(config_stats, stats_chunks_high, ctl_stats.chunks.high, size_t)
+CTL_RO_CGEN(config_stats, stats_huge_allocated, huge_allocated, size_t)
+CTL_RO_CGEN(config_stats, stats_huge_nmalloc, huge_nmalloc, uint64_t)
+CTL_RO_CGEN(config_stats, stats_huge_ndalloc, huge_ndalloc, uint64_t)
+CTL_RO_CGEN(config_stats, stats_arenas_i_small_allocated,
     ctl_stats.arenas[mib[2]].allocated_small, size_t)
-CTL_RO_GEN(stats_arenas_i_small_nmalloc,
+CTL_RO_CGEN(config_stats, stats_arenas_i_small_nmalloc,
     ctl_stats.arenas[mib[2]].nmalloc_small, uint64_t)
-CTL_RO_GEN(stats_arenas_i_small_ndalloc,
+CTL_RO_CGEN(config_stats, stats_arenas_i_small_ndalloc,
     ctl_stats.arenas[mib[2]].ndalloc_small, uint64_t)
-CTL_RO_GEN(stats_arenas_i_small_nrequests,
+CTL_RO_CGEN(config_stats, stats_arenas_i_small_nrequests,
     ctl_stats.arenas[mib[2]].nrequests_small, uint64_t)
-CTL_RO_GEN(stats_arenas_i_large_allocated,
+CTL_RO_CGEN(config_stats, stats_arenas_i_large_allocated,
     ctl_stats.arenas[mib[2]].astats.allocated_large, size_t)
-CTL_RO_GEN(stats_arenas_i_large_nmalloc,
+CTL_RO_CGEN(config_stats, stats_arenas_i_large_nmalloc,
     ctl_stats.arenas[mib[2]].astats.nmalloc_large, uint64_t)
-CTL_RO_GEN(stats_arenas_i_large_ndalloc,
+CTL_RO_CGEN(config_stats, stats_arenas_i_large_ndalloc,
     ctl_stats.arenas[mib[2]].astats.ndalloc_large, uint64_t)
-CTL_RO_GEN(stats_arenas_i_large_nrequests,
+CTL_RO_CGEN(config_stats, stats_arenas_i_large_nrequests,
     ctl_stats.arenas[mib[2]].astats.nrequests_large, uint64_t)
 
-CTL_RO_GEN(stats_arenas_i_bins_j_allocated,
+CTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_allocated,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].allocated, size_t)
-CTL_RO_GEN(stats_arenas_i_bins_j_nmalloc,
+CTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nmalloc,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].nmalloc, uint64_t)
-CTL_RO_GEN(stats_arenas_i_bins_j_ndalloc,
+CTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_ndalloc,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].ndalloc, uint64_t)
-CTL_RO_GEN(stats_arenas_i_bins_j_nrequests,
+CTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nrequests,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].nrequests, uint64_t)
-#ifdef JEMALLOC_TCACHE
-CTL_RO_GEN(stats_arenas_i_bins_j_nfills,
+CTL_RO_CGEN(config_stats && config_tcache, stats_arenas_i_bins_j_nfills,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].nfills, uint64_t)
-CTL_RO_GEN(stats_arenas_i_bins_j_nflushes,
+CTL_RO_CGEN(config_stats && config_tcache, stats_arenas_i_bins_j_nflushes,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].nflushes, uint64_t)
-#endif
-CTL_RO_GEN(stats_arenas_i_bins_j_nruns,
+CTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nruns,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].nruns, uint64_t)
-CTL_RO_GEN(stats_arenas_i_bins_j_nreruns,
+CTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_nreruns,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].reruns, uint64_t)
-CTL_RO_GEN(stats_arenas_i_bins_j_highruns,
+CTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_highruns,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].highruns, size_t)
-CTL_RO_GEN(stats_arenas_i_bins_j_curruns,
+CTL_RO_CGEN(config_stats, stats_arenas_i_bins_j_curruns,
     ctl_stats.arenas[mib[2]].bstats[mib[4]].curruns, size_t)
 
 const ctl_node_t *
@@ -1531,15 +1397,15 @@ stats_arenas_i_bins_j_index(const size_t *mib, size_t miblen, size_t j)
 	return (super_stats_arenas_i_bins_j_node);
 }
 
-CTL_RO_GEN(stats_arenas_i_lruns_j_nmalloc,
+CTL_RO_CGEN(config_stats, stats_arenas_i_lruns_j_nmalloc,
     ctl_stats.arenas[mib[2]].lstats[mib[4]].nmalloc, uint64_t)
-CTL_RO_GEN(stats_arenas_i_lruns_j_ndalloc,
+CTL_RO_CGEN(config_stats, stats_arenas_i_lruns_j_ndalloc,
     ctl_stats.arenas[mib[2]].lstats[mib[4]].ndalloc, uint64_t)
-CTL_RO_GEN(stats_arenas_i_lruns_j_nrequests,
+CTL_RO_CGEN(config_stats, stats_arenas_i_lruns_j_nrequests,
     ctl_stats.arenas[mib[2]].lstats[mib[4]].nrequests, uint64_t)
-CTL_RO_GEN(stats_arenas_i_lruns_j_curruns,
+CTL_RO_CGEN(config_stats, stats_arenas_i_lruns_j_curruns,
     ctl_stats.arenas[mib[2]].lstats[mib[4]].curruns, size_t)
-CTL_RO_GEN(stats_arenas_i_lruns_j_highruns,
+CTL_RO_CGEN(config_stats, stats_arenas_i_lruns_j_highruns,
     ctl_stats.arenas[mib[2]].lstats[mib[4]].highruns, size_t)
 
 const ctl_node_t *
@@ -1551,20 +1417,17 @@ stats_arenas_i_lruns_j_index(const size_t *mib, size_t miblen, size_t j)
 	return (super_stats_arenas_i_lruns_j_node);
 }
 
-#endif
 CTL_RO_GEN(stats_arenas_i_nthreads, ctl_stats.arenas[mib[2]].nthreads, unsigned)
 CTL_RO_GEN(stats_arenas_i_pactive, ctl_stats.arenas[mib[2]].pactive, size_t)
 CTL_RO_GEN(stats_arenas_i_pdirty, ctl_stats.arenas[mib[2]].pdirty, size_t)
-#ifdef JEMALLOC_STATS
-CTL_RO_GEN(stats_arenas_i_mapped, ctl_stats.arenas[mib[2]].astats.mapped,
-    size_t)
-CTL_RO_GEN(stats_arenas_i_npurge, ctl_stats.arenas[mib[2]].astats.npurge,
-    uint64_t)
-CTL_RO_GEN(stats_arenas_i_nmadvise, ctl_stats.arenas[mib[2]].astats.nmadvise,
-    uint64_t)
-CTL_RO_GEN(stats_arenas_i_purged, ctl_stats.arenas[mib[2]].astats.purged,
-    uint64_t)
-#endif
+CTL_RO_CGEN(config_stats, stats_arenas_i_mapped,
+    ctl_stats.arenas[mib[2]].astats.mapped, size_t)
+CTL_RO_CGEN(config_stats, stats_arenas_i_npurge,
+    ctl_stats.arenas[mib[2]].astats.npurge, uint64_t)
+CTL_RO_CGEN(config_stats, stats_arenas_i_nmadvise,
+    ctl_stats.arenas[mib[2]].astats.nmadvise, uint64_t)
+CTL_RO_CGEN(config_stats, stats_arenas_i_purged,
+    ctl_stats.arenas[mib[2]].astats.purged, uint64_t)
 
 const ctl_node_t *
 stats_arenas_i_index(const size_t *mib, size_t miblen, size_t i)
@@ -1583,19 +1446,15 @@ RETURN:
 	return (ret);
 }
 
-#ifdef JEMALLOC_STATS
-CTL_RO_GEN(stats_cactive, &stats_cactive, size_t *)
-CTL_RO_GEN(stats_allocated, ctl_stats.allocated, size_t)
-CTL_RO_GEN(stats_active, ctl_stats.active, size_t)
-CTL_RO_GEN(stats_mapped, ctl_stats.mapped, size_t)
-#endif
+CTL_RO_CGEN(config_stats, stats_cactive, &stats_cactive, size_t *)
+CTL_RO_CGEN(config_stats, stats_allocated, ctl_stats.allocated, size_t)
+CTL_RO_CGEN(config_stats, stats_active, ctl_stats.active, size_t)
+CTL_RO_CGEN(config_stats, stats_mapped, ctl_stats.mapped, size_t)
 
 /******************************************************************************/
 
-#ifdef JEMALLOC_SWAP
-#  ifdef JEMALLOC_STATS
-CTL_RO_GEN(swap_avail, ctl_stats.swap_avail, size_t)
-#  endif
+CTL_RO_CGEN(config_swap && config_stats, swap_avail, ctl_stats.swap_avail,
+    size_t)
 
 static int
 swap_prezeroed_ctl(const size_t *mib, size_t miblen, void *oldp,
@@ -1603,6 +1462,9 @@ swap_prezeroed_ctl(const size_t *mib, size_t miblen, void *oldp,
 {
 	int ret;
 
+	if (config_swap == false)
+		return (ENOENT);
+
 	malloc_mutex_lock(&ctl_mtx);
 	if (swap_enabled) {
 		READONLY();
@@ -1625,7 +1487,7 @@ RETURN:
 	return (ret);
 }
 
-CTL_RO_GEN(swap_nfds, swap_nfds, size_t)
+CTL_RO_CGEN(config_swap, swap_nfds, swap_nfds, size_t)
 
 static int
 swap_fds_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
@@ -1633,6 +1495,9 @@ swap_fds_ctl(const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp,
 {
 	int ret;
 
+	if (config_swap == false)
+		return (ENOENT);
+
 	malloc_mutex_lock(&ctl_mtx);
 	if (swap_enabled) {
 		READONLY();
@@ -1667,4 +1532,3 @@ RETURN:
 	malloc_mutex_unlock(&ctl_mtx);
 	return (ret);
 }
-#endif