Pull in the CTF sources from the FreeBSD 8.2 tree; arrange for them

to build under autoconf.

1 files changed, 1011 insertions, 0 deletions

diff --git a/cvt/ctfmerge.c b/cvt/ctfmerge.c
new file mode 100644
index 0000000..f9d7237
--- /dev/null
+++ b/cvt/ctfmerge.c
@@ -0,0 +1,1011 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+/*
+ * Given several files containing CTF data, merge and uniquify that data into
+ * a single CTF section in an output file.
+ *
+ * Merges can proceed independently.  As such, we perform the merges in parallel
+ * using a worker thread model.  A given glob of CTF data (either all of the CTF
+ * data from a single input file, or the result of one or more merges) can only
+ * be involved in a single merge at any given time, so the process decreases in
+ * parallelism, especially towards the end, as more and more files are
+ * consolidated, finally resulting in a single merge of two large CTF graphs.
+ * Unfortunately, the last merge is also the slowest, as the two graphs being
+ * merged are each the product of merges of half of the input files.
+ *
+ * The algorithm consists of two phases, described in detail below.  The first
+ * phase entails the merging of CTF data in groups of eight.  The second phase
+ * takes the results of Phase I, and merges them two at a time.  This disparity
+ * is due to an observation that the merge time increases at least quadratically
+ * with the size of the CTF data being merged.  As such, merges of CTF graphs
+ * newly read from input files are much faster than merges of CTF graphs that
+ * are themselves the results of prior merges.
+ *
+ * A further complication is the need to ensure the repeatability of CTF merges.
+ * That is, a merge should produce the same output every time, given the same
+ * input.  In both phases, this consistency requirement is met by imposing an
+ * ordering on the merge process, thus ensuring that a given set of input files
+ * are merged in the same order every time.
+ *
+ *   Phase I
+ *
+ *   The main thread reads the input files one by one, transforming the CTF
+ *   data they contain into tdata structures.  When a given file has been read
+ *   and parsed, it is placed on the work queue for retrieval by worker threads.
+ *
+ *   Central to Phase I is the Work In Progress (wip) array, which is used to
+ *   merge batches of files in a predictable order.  Files are read by the main
+ *   thread, and are merged into wip array elements in round-robin order.  When
+ *   the number of files merged into a given array slot equals the batch size,
+ *   the merged CTF graph in that array is added to the done slot in order by
+ *   array slot.
+ *
+ *   For example, consider a case where we have five input files, a batch size
+ *   of two, a wip array size of two, and two worker threads (T1 and T2).
+ *
+ *    1. The wip array elements are assigned initial batch numbers 0 and 1.
+ *    2. T1 reads an input file from the input queue (wq_queue).  This is the
+ *       first input file, so it is placed into wip[0].  The second file is
+ *       similarly read and placed into wip[1].  The wip array slots now contain
+ *       one file each (wip_nmerged == 1).
+ *    3. T1 reads the third input file, which it merges into wip[0].  The
+ *       number of files in wip[0] is equal to the batch size.
+ *    4. T2 reads the fourth input file, which it merges into wip[1].  wip[1]
+ *       is now full too.
+ *    5. T2 attempts to place the contents of wip[1] on the done queue
+ *       (wq_done_queue), but it can't, since the batch ID for wip[1] is 1.
+ *       Batch 0 needs to be on the done queue before batch 1 can be added, so
+ *       T2 blocks on wip[1]'s cv.
+ *    6. T1 attempts to place the contents of wip[0] on the done queue, and
+ *       succeeds, updating wq_lastdonebatch to 0.  It clears wip[0], and sets
+ *       its batch ID to 2.  T1 then signals wip[1]'s cv to awaken T2.
+ *    7. T2 wakes up, notices that wq_lastdonebatch is 0, which means that
+ *       batch 1 can now be added.  It adds wip[1] to the done queue, clears
+ *       wip[1], and sets its batch ID to 3.  It signals wip[0]'s cv, and
+ *       restarts.
+ *
+ *   The above process continues until all input files have been consumed.  At
+ *   this point, a pair of barriers are used to allow a single thread to move
+ *   any partial batches from the wip array to the done array in batch ID order.
+ *   When this is complete, wq_done_queue is moved to wq_queue, and Phase II
+ *   begins.
+ *
+ *	Locking Semantics (Phase I)
+ *
+ *	The input queue (wq_queue) and the done queue (wq_done_queue) are
+ *	protected by separate mutexes - wq_queue_lock and wq_done_queue.  wip
+ *	array slots are protected by their own mutexes, which must be grabbed
+ *	before releasing the input queue lock.  The wip array lock is dropped
+ *	when the thread restarts the loop.  If the array slot was full, the
+ *	array lock will be held while the slot contents are added to the done
+ *	queue.  The done queue lock is used to protect the wip slot cv's.
+ *
+ *	The pow number is protected by the queue lock.  The master batch ID
+ *	and last completed batch (wq_lastdonebatch) counters are protected *in
+ *	Phase I* by the done queue lock.
+ *
+ *   Phase II
+ *
+ *   When Phase II begins, the queue consists of the merged batches from the
+ *   first phase.  Assume we have five batches:
+ *
+ *	Q:	a b c d e
+ *
+ *   Using the same batch ID mechanism we used in Phase I, but without the wip
+ *   array, worker threads remove two entries at a time from the beginning of
+ *   the queue.  These two entries are merged, and are added back to the tail
+ *   of the queue, as follows:
+ *
+ *	Q:	a b c d e	# start
+ *	Q:	c d e ab	# a, b removed, merged, added to end
+ *	Q:	e ab cd		# c, d removed, merged, added to end
+ *	Q:	cd eab		# e, ab removed, merged, added to end
+ *	Q:	cdeab		# cd, eab removed, merged, added to end
+ *
+ *   When one entry remains on the queue, with no merges outstanding, Phase II
+ *   finishes.  We pre-determine the stopping point by pre-calculating the
+ *   number of nodes that will appear on the list.  In the example above, the
+ *   number (wq_ninqueue) is 9.  When ninqueue is 1, we conclude Phase II by
+ *   signaling the main thread via wq_done_cv.
+ *
+ *	Locking Semantics (Phase II)
+ *
+ *	The queue (wq_queue), ninqueue, and the master batch ID and last
+ *	completed batch counters are protected by wq_queue_lock.  The done
+ *	queue and corresponding lock are unused in Phase II as is the wip array.
+ *
+ *   Uniquification
+ *
+ *   We want the CTF data that goes into a given module to be as small as
+ *   possible.  For example, we don't want it to contain any type data that may
+ *   be present in another common module.  As such, after creating the master
+ *   tdata_t for a given module, we can, if requested by the user, uniquify it
+ *   against the tdata_t from another module (genunix in the case of the SunOS
+ *   kernel).  We perform a merge between the tdata_t for this module and the
+ *   tdata_t from genunix.  Nodes found in this module that are not present in
+ *   genunix are added to a third tdata_t - the uniquified tdata_t.
+ *
+ *   Additive Merges
+ *
+ *   In some cases, for example if we are issuing a new version of a common
+ *   module in a patch, we need to make sure that the CTF data already present
+ *   in that module does not change.  Changes to this data would void the CTF
+ *   data in any module that uniquified against the common module.  To preserve
+ *   the existing data, we can perform what is known as an additive merge.  In
+ *   this case, a final uniquification is performed against the CTF data in the
+ *   previous version of the module.  The result will be the placement of new
+ *   and changed data after the existing data, thus preserving the existing type
+ *   ID space.
+ *
+ *   Saving the result
+ *
+ *   When the merges are complete, the resulting tdata_t is placed into the
+ *   output file, replacing the .SUNW_ctf section (if any) already in that file.
+ *
+ * The person who changes the merging thread code in this file without updating
+ * this comment will not live to see the stock hit five.
+ */
+
+#include "libctf/ctf_impl.h"
+#if defined(sun)
+#include <synch.h>
+#endif
+#if defined(sun)
+#include <alloca.h>
+#endif
+#if defined(sun)
+#include <sys/sysconf.h>
+#endif
+#include "ctftools.h"
+#include "ctfmerge.h"
+#include "traverse.h"
+#include "memory.h"
+#include "fifo.h"
+#include "barrier.h"
+
+#pragma init(bigheap)
+
+#define	MERGE_PHASE1_BATCH_SIZE		8
+#define	MERGE_PHASE1_MAX_SLOTS		5
+#define	MERGE_INPUT_THROTTLE_LEN	10
+
+const char *progname;
+static char *outfile = NULL;
+static char *tmpname = NULL;
+static int dynsym;
+int debug_level = DEBUG_LEVEL;
+static size_t maxpgsize = 0x400000;
+
+
+void
+usage(void)
+{
+	(void) fprintf(stderr,
+	    "Usage: %s [-fgstv] -l label | -L labelenv -o outfile file ...\n"
+	    "       %s [-fgstv] -l label | -L labelenv -o outfile -d uniqfile\n"
+	    "       %*s [-g] [-D uniqlabel] file ...\n"
+	    "       %s [-fgstv] -l label | -L labelenv -o outfile -w withfile "
+	    "file ...\n"
+	    "       %s [-g] -c srcfile destfile\n"
+	    "\n"
+	    "  Note: if -L labelenv is specified and labelenv is not set in\n"
+	    "  the environment, a default value is used.\n",
+	    progname, progname, strlen(progname), " ",
+	    progname, progname);
+}
+
+#if defined(sun)
+static void
+bigheap(void)
+{
+	size_t big, *size;
+	int sizes;
+	struct memcntl_mha mha;
+
+	/*
+	 * First, get the available pagesizes.
+	 */
+	if ((sizes = getpagesizes(NULL, 0)) == -1)
+		return;
+
+	if (sizes == 1 || (size = alloca(sizeof (size_t) * sizes)) == NULL)
+		return;
+
+	if (getpagesizes(size, sizes) == -1)
+		return;
+
+	while (size[sizes - 1] > maxpgsize)
+		sizes--;
+
+	/* set big to the largest allowed page size */
+	big = size[sizes - 1];
+	if (big & (big - 1)) {
+		/*
+		 * The largest page size is not a power of two for some
+		 * inexplicable reason; return.
+		 */
+		return;
+	}
+
+	/*
+	 * Now, align our break to the largest page size.
+	 */
+	if (brk((void *)((((uintptr_t)sbrk(0) - 1) & ~(big - 1)) + big)) != 0)
+		return;
+
+	/*
+	 * set the preferred page size for the heap
+	 */
+	mha.mha_cmd = MHA_MAPSIZE_BSSBRK;
+	mha.mha_flags = 0;
+	mha.mha_pagesize = big;
+
+	(void) memcntl(NULL, 0, MC_HAT_ADVISE, (caddr_t)&mha, 0, 0);
+}
+#endif
+
+static void
+finalize_phase_one(workqueue_t *wq)
+{
+	int startslot, i;
+
+	/*
+	 * wip slots are cleared out only when maxbatchsz td's have been merged
+	 * into them.  We're not guaranteed that the number of files we're
+	 * merging is a multiple of maxbatchsz, so there will be some partial
+	 * groups in the wip array.  Move them to the done queue in batch ID
+	 * order, starting with the slot containing the next batch that would
+	 * have been placed on the done queue, followed by the others.
+	 * One thread will be doing this while the others wait at the barrier
+	 * back in worker_thread(), so we don't need to worry about pesky things
+	 * like locks.
+	 */
+
+	for (startslot = -1, i = 0; i < wq->wq_nwipslots; i++) {
+		if (wq->wq_wip[i].wip_batchid == wq->wq_lastdonebatch + 1) {
+			startslot = i;
+			break;
+		}
+	}
+
+	assert(startslot != -1);
+
+	for (i = startslot; i < startslot + wq->wq_nwipslots; i++) {
+		int slotnum = i % wq->wq_nwipslots;
+		wip_t *wipslot = &wq->wq_wip[slotnum];
+
+		if (wipslot->wip_td != NULL) {
+			debug(2, "clearing slot %d (%d) (saving %d)\n",
+			    slotnum, i, wipslot->wip_nmerged);
+		} else
+			debug(2, "clearing slot %d (%d)\n", slotnum, i);
+
+		if (wipslot->wip_td != NULL) {
+			fifo_add(wq->wq_donequeue, wipslot->wip_td);
+			wq->wq_wip[slotnum].wip_td = NULL;
+		}
+	}
+
+	wq->wq_lastdonebatch = wq->wq_next_batchid++;
+
+	debug(2, "phase one done: donequeue has %d items\n",
+	    fifo_len(wq->wq_donequeue));
+}
+
+static void
+init_phase_two(workqueue_t *wq)
+{
+	int num;
+
+	/*
+	 * We're going to continually merge the first two entries on the queue,
+	 * placing the result on the end, until there's nothing left to merge.
+	 * At that point, everything will have been merged into one.  The
+	 * initial value of ninqueue needs to be equal to the total number of
+	 * entries that will show up on the queue, both at the start of the
+	 * phase and as generated by merges during the phase.
+	 */
+	wq->wq_ninqueue = num = fifo_len(wq->wq_donequeue);
+	while (num != 1) {
+		wq->wq_ninqueue += num / 2;
+		num = num / 2 + num % 2;
+	}
+
+	/*
+	 * Move the done queue to the work queue.  We won't be using the done
+	 * queue in phase 2.
+	 */
+	assert(fifo_len(wq->wq_queue) == 0);
+	fifo_free(wq->wq_queue, NULL);
+	wq->wq_queue = wq->wq_donequeue;
+}
+
+static void
+wip_save_work(workqueue_t *wq, wip_t *slot, int slotnum)
+{
+	pthread_mutex_lock(&wq->wq_donequeue_lock);
+
+	while (wq->wq_lastdonebatch + 1 < slot->wip_batchid)
+		pthread_cond_wait(&slot->wip_cv, &wq->wq_donequeue_lock);
+	assert(wq->wq_lastdonebatch + 1 == slot->wip_batchid);
+
+	fifo_add(wq->wq_donequeue, slot->wip_td);
+	wq->wq_lastdonebatch++;
+	pthread_cond_signal(&wq->wq_wip[(slotnum + 1) %
+	    wq->wq_nwipslots].wip_cv);
+
+	/* reset the slot for next use */
+	slot->wip_td = NULL;
+	slot->wip_batchid = wq->wq_next_batchid++;
+
+	pthread_mutex_unlock(&wq->wq_donequeue_lock);
+}
+
+static void
+wip_add_work(wip_t *slot, tdata_t *pow)
+{
+	if (slot->wip_td == NULL) {
+		slot->wip_td = pow;
+		slot->wip_nmerged = 1;
+	} else {
+		debug(2, "%d: merging %p into %p\n", pthread_self(),
+		    (void *)pow, (void *)slot->wip_td);
+
+		merge_into_master(pow, slot->wip_td, NULL, 0);
+		tdata_free(pow);
+
+		slot->wip_nmerged++;
+	}
+}
+
+static void
+worker_runphase1(workqueue_t *wq)
+{
+	wip_t *wipslot;
+	tdata_t *pow;
+	int wipslotnum, pownum;
+
+	for (;;) {
+		pthread_mutex_lock(&wq->wq_queue_lock);
+
+		while (fifo_empty(wq->wq_queue)) {
+			if (wq->wq_nomorefiles == 1) {
+				pthread_cond_broadcast(&wq->wq_work_avail);
+				pthread_mutex_unlock(&wq->wq_queue_lock);
+
+				/* on to phase 2 ... */
+				return;
+			}
+
+			pthread_cond_wait(&wq->wq_work_avail,
+			    &wq->wq_queue_lock);
+		}
+
+		/* there's work to be done! */
+		pow = fifo_remove(wq->wq_queue);
+		pownum = wq->wq_nextpownum++;
+		pthread_cond_broadcast(&wq->wq_work_removed);
+
+		assert(pow != NULL);
+
+		/* merge it into the right slot */
+		wipslotnum = pownum % wq->wq_nwipslots;
+		wipslot = &wq->wq_wip[wipslotnum];
+
+		pthread_mutex_lock(&wipslot->wip_lock);
+
+		pthread_mutex_unlock(&wq->wq_queue_lock);
+
+		wip_add_work(wipslot, pow);
+
+		if (wipslot->wip_nmerged == wq->wq_maxbatchsz)
+			wip_save_work(wq, wipslot, wipslotnum);
+
+		pthread_mutex_unlock(&wipslot->wip_lock);
+	}
+}
+
+static void
+worker_runphase2(workqueue_t *wq)
+{
+	tdata_t *pow1, *pow2;
+	int batchid;
+
+	for (;;) {
+		pthread_mutex_lock(&wq->wq_queue_lock);
+
+		if (wq->wq_ninqueue == 1) {
+			pthread_cond_broadcast(&wq->wq_work_avail);
+			pthread_mutex_unlock(&wq->wq_queue_lock);
+
+			debug(2, "%d: entering p2 completion barrier\n",
+			    pthread_self());
+			if (barrier_wait(&wq->wq_bar1)) {
+				pthread_mutex_lock(&wq->wq_queue_lock);
+				wq->wq_alldone = 1;
+				pthread_cond_signal(&wq->wq_alldone_cv);
+				pthread_mutex_unlock(&wq->wq_queue_lock);
+			}
+
+			return;
+		}
+
+		if (fifo_len(wq->wq_queue) < 2) {
+			pthread_cond_wait(&wq->wq_work_avail,
+			    &wq->wq_queue_lock);
+			pthread_mutex_unlock(&wq->wq_queue_lock);
+			continue;
+		}
+
+		/* there's work to be done! */
+		pow1 = fifo_remove(wq->wq_queue);
+		pow2 = fifo_remove(wq->wq_queue);
+		wq->wq_ninqueue -= 2;
+
+		batchid = wq->wq_next_batchid++;
+
+		pthread_mutex_unlock(&wq->wq_queue_lock);
+
+		debug(2, "%d: merging %p into %p\n", pthread_self(),
+		    (void *)pow1, (void *)pow2);
+		merge_into_master(pow1, pow2, NULL, 0);
+		tdata_free(pow1);
+
+		/*
+		 * merging is complete.  place at the tail of the queue in
+		 * proper order.
+		 */
+		pthread_mutex_lock(&wq->wq_queue_lock);
+		while (wq->wq_lastdonebatch + 1 != batchid) {
+			pthread_cond_wait(&wq->wq_done_cv,
+			    &wq->wq_queue_lock);
+		}
+
+		wq->wq_lastdonebatch = batchid;
+
+		fifo_add(wq->wq_queue, pow2);
+		debug(2, "%d: added %p to queue, len now %d, ninqueue %d\n",
+		    pthread_self(), (void *)pow2, fifo_len(wq->wq_queue),
+		    wq->wq_ninqueue);
+		pthread_cond_broadcast(&wq->wq_done_cv);
+		pthread_cond_signal(&wq->wq_work_avail);
+		pthread_mutex_unlock(&wq->wq_queue_lock);
+	}
+}
+
+/*
+ * Main loop for worker threads.
+ */
+static void
+worker_thread(workqueue_t *wq)
+{
+	worker_runphase1(wq);
+
+	debug(2, "%d: entering first barrier\n", pthread_self());
+
+	if (barrier_wait(&wq->wq_bar1)) {
+
+		debug(2, "%d: doing work in first barrier\n", pthread_self());
+
+		finalize_phase_one(wq);
+
+		init_phase_two(wq);
+
+		debug(2, "%d: ninqueue is %d, %d on queue\n", pthread_self(),
+		    wq->wq_ninqueue, fifo_len(wq->wq_queue));
+	}
+
+	debug(2, "%d: entering second barrier\n", pthread_self());
+
+	(void) barrier_wait(&wq->wq_bar2);
+
+	debug(2, "%d: phase 1 complete\n", pthread_self());
+
+	worker_runphase2(wq);
+}
+
+/*
+ * Pass a tdata_t tree, built from an input file, off to the work queue for
+ * consumption by worker threads.
+ */
+static int
+merge_ctf_cb(tdata_t *td, char *name, void *arg)
+{
+	workqueue_t *wq = arg;
+
+	debug(3, "Adding tdata %p for processing\n", (void *)td);
+
+	pthread_mutex_lock(&wq->wq_queue_lock);
+	while (fifo_len(wq->wq_queue) > wq->wq_ithrottle) {
+		debug(2, "Throttling input (len = %d, throttle = %d)\n",
+		    fifo_len(wq->wq_queue), wq->wq_ithrottle);
+		pthread_cond_wait(&wq->wq_work_removed, &wq->wq_queue_lock);
+	}
+
+	fifo_add(wq->wq_queue, td);
+	debug(1, "Thread %d announcing %s\n", pthread_self(), name);
+	pthread_cond_broadcast(&wq->wq_work_avail);
+	pthread_mutex_unlock(&wq->wq_queue_lock);
+
+	return (1);
+}
+
+/*
+ * This program is intended to be invoked from a Makefile, as part of the build.
+ * As such, in the event of a failure or user-initiated interrupt (^C), we need
+ * to ensure that a subsequent re-make will cause ctfmerge to be executed again.
+ * Unfortunately, ctfmerge will usually be invoked directly after (and as part
+ * of the same Makefile rule as) a link, and will operate on the linked file
+ * in place.  If we merely exit upon receipt of a SIGINT, a subsequent make
+ * will notice that the *linked* file is newer than the object files, and thus
+ * will not reinvoke ctfmerge.  The only way to ensure that a subsequent make
+ * reinvokes ctfmerge, is to remove the file to which we are adding CTF
+ * data (confusingly named the output file).  This means that the link will need
+ * to happen again, but links are generally fast, and we can't allow the merge
+ * to be skipped.
+ *
+ * Another possibility would be to block SIGINT entirely - to always run to
+ * completion.  The run time of ctfmerge can, however, be measured in minutes
+ * in some cases, so this is not a valid option.
+ */
+static void
+handle_sig(int sig)
+{
+	terminate("Caught signal %d - exiting\n", sig);
+}
+
+static void
+terminate_cleanup(void)
+{
+	int dounlink = getenv("CTFMERGE_TERMINATE_NO_UNLINK") ? 0 : 1;
+
+	if (tmpname != NULL && dounlink)
+		unlink(tmpname);
+
+	if (outfile == NULL)
+		return;
+
+#if !defined(__FreeBSD__)
+	if (dounlink) {
+		fprintf(stderr, "Removing %s\n", outfile);
+		unlink(outfile);
+	}
+#endif
+}
+
+static void
+copy_ctf_data(char *srcfile, char *destfile, int keep_stabs)
+{
+	tdata_t *srctd;
+
+	if (read_ctf(&srcfile, 1, NULL, read_ctf_save_cb, &srctd, 1) == 0)
+		terminate("No CTF data found in source file %s\n", srcfile);
+
+	tmpname = mktmpname(destfile, ".ctf");
+	write_ctf(srctd, destfile, tmpname, CTF_COMPRESS | keep_stabs);
+	if (rename(tmpname, destfile) != 0) {
+		terminate("Couldn't rename temp file %s to %s", tmpname,
+		    destfile);
+	}
+	free(tmpname);
+	tdata_free(srctd);
+}
+
+static void
+wq_init(workqueue_t *wq, int nfiles)
+{
+	int throttle, nslots, i;
+
+	if (getenv("CTFMERGE_MAX_SLOTS"))
+		nslots = atoi(getenv("CTFMERGE_MAX_SLOTS"));
+	else
+		nslots = MERGE_PHASE1_MAX_SLOTS;
+
+	if (getenv("CTFMERGE_PHASE1_BATCH_SIZE"))
+		wq->wq_maxbatchsz = atoi(getenv("CTFMERGE_PHASE1_BATCH_SIZE"));
+	else
+		wq->wq_maxbatchsz = MERGE_PHASE1_BATCH_SIZE;
+
+	nslots = MIN(nslots, (nfiles + wq->wq_maxbatchsz - 1) /
+	    wq->wq_maxbatchsz);
+
+	wq->wq_wip = xcalloc(sizeof (wip_t) * nslots);
+	wq->wq_nwipslots = nslots;
+	wq->wq_nthreads = MIN(sysconf(_SC_NPROCESSORS_ONLN) * 3 / 2, nslots);
+	wq->wq_thread = xmalloc(sizeof (pthread_t) * wq->wq_nthreads);
+
+	if (getenv("CTFMERGE_INPUT_THROTTLE"))
+		throttle = atoi(getenv("CTFMERGE_INPUT_THROTTLE"));
+	else
+		throttle = MERGE_INPUT_THROTTLE_LEN;
+	wq->wq_ithrottle = throttle * wq->wq_nthreads;
+
+	debug(1, "Using %d slots, %d threads\n", wq->wq_nwipslots,
+	    wq->wq_nthreads);
+
+	wq->wq_next_batchid = 0;
+
+	for (i = 0; i < nslots; i++) {
+		pthread_mutex_init(&wq->wq_wip[i].wip_lock, NULL);
+		wq->wq_wip[i].wip_batchid = wq->wq_next_batchid++;
+	}
+
+	pthread_mutex_init(&wq->wq_queue_lock, NULL);
+	wq->wq_queue = fifo_new();
+	pthread_cond_init(&wq->wq_work_avail, NULL);
+	pthread_cond_init(&wq->wq_work_removed, NULL);
+	wq->wq_ninqueue = nfiles;
+	wq->wq_nextpownum = 0;
+
+	pthread_mutex_init(&wq->wq_donequeue_lock, NULL);
+	wq->wq_donequeue = fifo_new();
+	wq->wq_lastdonebatch = -1;
+
+	pthread_cond_init(&wq->wq_done_cv, NULL);
+
+	pthread_cond_init(&wq->wq_alldone_cv, NULL);
+	wq->wq_alldone = 0;
+
+	barrier_init(&wq->wq_bar1, wq->wq_nthreads);
+	barrier_init(&wq->wq_bar2, wq->wq_nthreads);
+
+	wq->wq_nomorefiles = 0;
+}
+
+static void
+start_threads(workqueue_t *wq)
+{
+	sigset_t sets;
+	int i;
+
+	sigemptyset(&sets);
+	sigaddset(&sets, SIGINT);
+	sigaddset(&sets, SIGQUIT);
+	sigaddset(&sets, SIGTERM);
+	pthread_sigmask(SIG_BLOCK, &sets, NULL);
+
+	for (i = 0; i < wq->wq_nthreads; i++) {
+		pthread_create(&wq->wq_thread[i], NULL,
+		    (void *(*)(void *))worker_thread, wq);
+	}
+
+#if defined(sun)
+	sigset(SIGINT, handle_sig);
+	sigset(SIGQUIT, handle_sig);
+	sigset(SIGTERM, handle_sig);
+#else
+	signal(SIGINT, handle_sig);
+	signal(SIGQUIT, handle_sig);
+	signal(SIGTERM, handle_sig);
+#endif
+	pthread_sigmask(SIG_UNBLOCK, &sets, NULL);
+}
+
+static void
+join_threads(workqueue_t *wq)
+{
+	int i;
+
+	for (i = 0; i < wq->wq_nthreads; i++) {
+		pthread_join(wq->wq_thread[i], NULL);
+	}
+}
+
+static int
+strcompare(const void *p1, const void *p2)
+{
+	char *s1 = *((char **)p1);
+	char *s2 = *((char **)p2);
+
+	return (strcmp(s1, s2));
+}
+
+/*
+ * Core work queue structure; passed to worker threads on thread creation
+ * as the main point of coordination.  Allocate as a static structure; we
+ * could have put this into a local variable in main, but passing a pointer
+ * into your stack to another thread is fragile at best and leads to some
+ * hard-to-debug failure modes.
+ */
+static workqueue_t wq;
+
+int
+main(int argc, char **argv)
+{
+	tdata_t *mstrtd, *savetd;
+	char *uniqfile = NULL, *uniqlabel = NULL;
+	char *withfile = NULL;
+	char *label = NULL;
+	char **ifiles, **tifiles;
+	int verbose = 0, docopy = 0;
+	int write_fuzzy_match = 0;
+	int keep_stabs = 0;
+	int require_ctf = 0;
+	int nifiles, nielems;
+	int c, i, idx, tidx, err;
+
+	progname = basename(argv[0]);
+
+	if (getenv("CTFMERGE_DEBUG_LEVEL"))
+		debug_level = atoi(getenv("CTFMERGE_DEBUG_LEVEL"));
+
+	err = 0;
+	while ((c = getopt(argc, argv, ":cd:D:fgl:L:o:tvw:s")) != EOF) {
+		switch (c) {
+		case 'c':
+			docopy = 1;
+			break;
+		case 'd':
+			/* Uniquify against `uniqfile' */
+			uniqfile = optarg;
+			break;
+		case 'D':
+			/* Uniquify against label `uniqlabel' in `uniqfile' */
+			uniqlabel = optarg;
+			break;
+		case 'f':
+			write_fuzzy_match = CTF_FUZZY_MATCH;
+			break;
+		case 'g':
+			keep_stabs = CTF_KEEP_STABS;
+			break;
+		case 'l':
+			/* Label merged types with `label' */
+			label = optarg;
+			break;
+		case 'L':
+			/* Label merged types with getenv(`label`) */
+			if ((label = getenv(optarg)) == NULL)
+				label = CTF_DEFAULT_LABEL;
+			break;
+		case 'o':
+			/* Place merged types in CTF section in `outfile' */
+			outfile = optarg;
+			break;
+		case 't':
+			/* Insist *all* object files built from C have CTF */
+			require_ctf = 1;
+			break;
+		case 'v':
+			/* More debugging information */
+			verbose = 1;
+			break;
+		case 'w':
+			/* Additive merge with data from `withfile' */
+			withfile = optarg;
+			break;
+		case 's':
+			/* use the dynsym rather than the symtab */
+			dynsym = CTF_USE_DYNSYM;
+			break;
+		default:
+			usage();
+			exit(2);
+		}
+	}
+
+	/* Validate arguments */
+	if (docopy) {
+		if (uniqfile != NULL || uniqlabel != NULL || label != NULL ||
+		    outfile != NULL || withfile != NULL || dynsym != 0)
+			err++;
+
+		if (argc - optind != 2)
+			err++;
+	} else {
+		if (uniqfile != NULL && withfile != NULL)
+			err++;
+
+		if (uniqlabel != NULL && uniqfile == NULL)
+			err++;
+
+		if (outfile == NULL || label == NULL)
+			err++;
+
+		if (argc - optind == 0)
+			err++;
+	}
+
+	if (err) {
+		usage();
+		exit(2);
+	}
+
+	if (getenv("STRIPSTABS_KEEP_STABS") != NULL)
+		keep_stabs = CTF_KEEP_STABS;
+
+	if (uniqfile && access(uniqfile, R_OK) != 0) {
+		warning("Uniquification file %s couldn't be opened and "
+		    "will be ignored.\n", uniqfile);
+		uniqfile = NULL;
+	}
+	if (withfile && access(withfile, R_OK) != 0) {
+		warning("With file %s couldn't be opened and will be "
+		    "ignored.\n", withfile);
+		withfile = NULL;
+	}
+	if (outfile && access(outfile, R_OK|W_OK) != 0)
+		terminate("Cannot open output file %s for r/w", outfile);
+
+	/*
+	 * This is ugly, but we don't want to have to have a separate tool
+	 * (yet) just for copying an ELF section with our specific requirements,
+	 * so we shoe-horn a copier into ctfmerge.
+	 */
+	if (docopy) {
+		copy_ctf_data(argv[optind], argv[optind + 1], keep_stabs);
+
+		exit(0);
+	}
+
+	set_terminate_cleanup(terminate_cleanup);
+
+	/* Sort the input files and strip out duplicates */
+	nifiles = argc - optind;
+	ifiles = xmalloc(sizeof (char *) * nifiles);
+	tifiles = xmalloc(sizeof (char *) * nifiles);
+
+	for (i = 0; i < nifiles; i++)
+		tifiles[i] = argv[optind + i];
+	qsort(tifiles, nifiles, sizeof (char *), (int (*)())strcompare);
+
+	ifiles[0] = tifiles[0];
+	for (idx = 0, tidx = 1; tidx < nifiles; tidx++) {
+		if (strcmp(ifiles[idx], tifiles[tidx]) != 0)
+			ifiles[++idx] = tifiles[tidx];
+	}
+	nifiles = idx + 1;
+
+	/* Make sure they all exist */
+	if ((nielems = count_files(ifiles, nifiles)) < 0)
+		terminate("Some input files were inaccessible\n");
+
+	/* Prepare for the merge */
+	wq_init(&wq, nielems);
+
+	start_threads(&wq);
+
+	/*
+	 * Start the merge
+	 *
+	 * We're reading everything from each of the object files, so we
+	 * don't need to specify labels.
+	 */
+	if (read_ctf(ifiles, nifiles, NULL, merge_ctf_cb,
+	    &wq, require_ctf) == 0) {
+		/*
+		 * If we're verifying that C files have CTF, it's safe to
+		 * assume that in this case, we're building only from assembly
+		 * inputs.
+		 */
+		if (require_ctf)
+			exit(0);
+		terminate("No ctf sections found to merge\n");
+	}
+
+	pthread_mutex_lock(&wq.wq_queue_lock);
+	wq.wq_nomorefiles = 1;
+	pthread_cond_broadcast(&wq.wq_work_avail);
+	pthread_mutex_unlock(&wq.wq_queue_lock);
+
+	pthread_mutex_lock(&wq.wq_queue_lock);
+	while (wq.wq_alldone == 0)
+		pthread_cond_wait(&wq.wq_alldone_cv, &wq.wq_queue_lock);
+	pthread_mutex_unlock(&wq.wq_queue_lock);
+
+	join_threads(&wq);
+
+	/*
+	 * All requested files have been merged, with the resulting tree in
+	 * mstrtd.  savetd is the tree that will be placed into the output file.
+	 *
+	 * Regardless of whether we're doing a normal uniquification or an
+	 * additive merge, we need a type tree that has been uniquified
+	 * against uniqfile or withfile, as appropriate.
+	 *
+	 * If we're doing a uniquification, we stuff the resulting tree into
+	 * outfile.  Otherwise, we add the tree to the tree already in withfile.
+	 */
+	assert(fifo_len(wq.wq_queue) == 1);
+	mstrtd = fifo_remove(wq.wq_queue);
+
+	if (verbose || debug_level) {
+		debug(2, "Statistics for td %p\n", (void *)mstrtd);
+
+		iidesc_stats(mstrtd->td_iihash);
+	}
+
+	if (uniqfile != NULL || withfile != NULL) {
+		char *reffile, *reflabel = NULL;
+		tdata_t *reftd;
+
+		if (uniqfile != NULL) {
+			reffile = uniqfile;
+			reflabel = uniqlabel;
+		} else
+			reffile = withfile;
+
+		if (read_ctf(&reffile, 1, reflabel, read_ctf_save_cb,
+		    &reftd, require_ctf) == 0) {
+			terminate("No CTF data found in reference file %s\n",
+			    reffile);
+		}
+
+		savetd = tdata_new();
+
+		if (CTF_TYPE_ISCHILD(reftd->td_nextid))
+			terminate("No room for additional types in master\n");
+
+		savetd->td_nextid = withfile ? reftd->td_nextid :
+		    CTF_INDEX_TO_TYPE(1, TRUE);
+		merge_into_master(mstrtd, reftd, savetd, 0);
+
+		tdata_label_add(savetd, label, CTF_LABEL_LASTIDX);
+
+		if (withfile) {
+			/*
+			 * savetd holds the new data to be added to the withfile
+			 */
+			tdata_t *withtd = reftd;
+
+			tdata_merge(withtd, savetd);
+
+			savetd = withtd;
+		} else {
+			char uniqname[MAXPATHLEN];
+			labelent_t *parle;
+
+			parle = tdata_label_top(reftd);
+
+			savetd->td_parlabel = xstrdup(parle->le_name);
+
+			strncpy(uniqname, reffile, sizeof (uniqname));
+			uniqname[MAXPATHLEN - 1] = '\0';
+			savetd->td_parname = xstrdup(basename(uniqname));
+		}
+
+	} else {
+		/*
+		 * No post processing.  Write the merged tree as-is into the
+		 * output file.
+		 */
+		tdata_label_free(mstrtd);
+		tdata_label_add(mstrtd, label, CTF_LABEL_LASTIDX);
+
+		savetd = mstrtd;
+	}
+
+	tmpname = mktmpname(outfile, ".ctf");
+	write_ctf(savetd, outfile, tmpname,
+	    CTF_COMPRESS | write_fuzzy_match | dynsym | keep_stabs);
+	if (rename(tmpname, outfile) != 0)
+		terminate("Couldn't rename output temp file %s", tmpname);
+	free(tmpname);
+
+	return (0);
+}