pjs/config/gtscc.c

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: NPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is 
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 1998
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the NPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the NPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */
/* */
/*
 *--------------------------------------------------------------------------
 *
 *    
 *
 *--------------------------------------------------------------------------
 *
 *    gtscc - Global To Static C/C++ compiler driver.
 *
 *    Syntax:
 *
 *    gtscc [options] -c file.cpp ...
 *    gtscc [options] file.o ... libxx.a ...
 *
 *    gtscc is a compiler and linker driver/wrapper for Irix only.
 *    gtscc takes all compiler options and passes them onto the Irix
 *    cc/CC compiler/linker.
 *    Typically, gtscc is used in two phases. Phase one is during compilation.
 *    gtscc, the compiler, converts all inline globals to statics, and records
 *    the existance of other globals and how to compile the file in the gtscc
 *    database file.
 *    During linking, globals dependencies are analyzed, and a list of
 *    "convertable" globals is determined. Globals that are not referenced
 *    globally, but are referenced locally are considered convertable.
 *    The linker then recompiles the files that those symbols are in, and
 *    converts them to statics. It also calls the archiver to install
 *    the converted objects into libraries.
 *    Finally the linker is called.
 *
 *    Created: David Williams, djw@netscape.com, 13-Feb-1997
 *
 *--------------------------------------------------------------------------
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/param.h>
#include <sys/types.h>
#include <unistd.h>
#include <ctype.h>

#if defined(LINUX) && defined(__GLIBC__)
#include <libelf/libelf.h>
#else
#include <libelf.h>
#endif

#include <sys/stat.h>
#include <fcntl.h>
#include <sys/time.h>

#define DEFAULT_MAX_GLOBALS 15500

#define ELFSYM_IS_DEFINED(x)   ((x).st_shndx != SHN_UNDEF)
#define ELFSYM_IS_UNDEFINED(x) ((x).st_shndx == SHN_UNDEF)

#ifdef IRIX
#define CC_COMMAND  "cc"
#define CCC_COMMAND "CC"
#define AS_COMMAND  "cc"
#define LD_COMMAND  "CC"
#define AR_COMMAND  "ar"
#define AR_OPTIONS  "cr"
#else
#define HANDLES_DASHSO
#define CC_COMMAND  "gcc"
#define CCC_COMMAND "g++"
#define AS_COMMAND  "gcc"
#define LD_COMMAND  "g++"
#define AR_COMMAND  "ar"
#define AR_OPTIONS  "cr"
#endif

#define EH_NEW(type) (type*)malloc(sizeof(type))

#define TRUE 1
#define FALSE 0

#define EH_TAG_FILE   'F'
#define EH_TAG_GLOBAL 'G'
#define EH_TAG_ZAPPED 'Z'
#define EH_TAG_INLINE 'I'
#define EH_TAG_UNDEFINED 'U'

#define VERBOSITY_USER(x)  ((x) > 0)
#define VERBOSITY_DEBUG(x) ((x) > 1)
#define VERBOSITY_MAJOR(x) ((x) > 2)

static char eh_unnamed_object[] = "<name not known>";

typedef struct {
	char*    name;       /* archive */
} EhArchive;

typedef struct {
	char*      name;     /* name of C/C++ file, relative to rootdir */
	char*      directory;/* must compile in this directory */
	char**     cc_args;  /* cc -I ..... */
	char*      as_savefile;
	time_t     compile_time;
	char*      target_object;
} EhSource;

typedef struct EhObject {
	struct EhObject* _recompile; /* used for recompilation link list */
	unsigned   _needs_unzap;
	char*      name;     /* name of .o */
	EhArchive* archive;  /* it is stored in */
	EhSource*  source;
	char*      pathname;
	unsigned   nusers;
} EhObject;

typedef enum {
	EH_SYM_UNDEFINED,
	EH_SYM_DEFINED,
	EH_SYM_ZAPPED,
	EH_SYM_INLINE /* are treated special - they belong to no file */
} EhSymState;

typedef struct EhSym {
	struct EhSym* _next; /* used for link list */
	char*      name;     /* name of symbol */
	EhObject*  object;   /* if symbol is undefined == NULL */
	unsigned   ngusers;   /* number of global users */
	unsigned   nlusers;   /* number of local file users */

#if 0
	unsigned   section;  /* section in elf file */
	unsigned   index;    /* index into symbol table */
	unsigned char info;
	unsigned   dirty;
#endif
	EhSymState state;
} EhSym;

#define EHSYM_ISDEFINED(x)   ((x)->object!=NULL && (x)->state==EH_SYM_DEFINED)
#define EHSYM_ISZAPPED(x)    ((x)->object!=NULL && (x)->state==EH_SYM_ZAPPED)
#define EHSYM_ISUNDEFINED(x) ((x)->object == NULL)
#define EHSYM_ISUSED(x)      ((x)->nusers != 0)
#define EHSYM_ISINLINE(x)    ((x)->state == EH_SYM_INLINE)

#define EH_OBJECT_CANBUILD(x) \
((x)->source != NULL && (x)->name != eh_unnamed_object)

#define USE_HASHING

typedef struct {
#ifdef USE_HASHING
	EhSym** heads;
	unsigned size;
#else
	EhSym* head;
#endif
	unsigned nentries;
} EhSymTable;

static char*
make_relative_pathname(char* buf, char* filename, char* rootdir)
{
	char  buf1[MAXPATHLEN];
	char  buf2[MAXPATHLEN];
	char* p;
	char* q;

	if (rootdir == NULL) {
		strcpy(buf, filename);
		return filename;
	}

	if (filename[0] != '/') {
		if (getcwd(buf2, sizeof(buf2)) == NULL) {
			fprintf(stderr, "cannot get pwd\n");
			return NULL;
		}

		strcat(buf2, "/");
		strcat(buf2, filename);

		filename = buf2;
	}

	if (realpath(filename, buf1) == NULL) {
		fprintf(stderr, "realpath(%s,..) failed\n", filename);
		return NULL;
	}
	
	if (realpath(rootdir, buf2) == NULL) {
		fprintf(stderr, "realpath(%s,..) failed\n", rootdir);
		return NULL;
	}

	strcat(buf2, "/");

	for (p = buf1, q = buf2; *p == *q; p++, q++)
		;

	strcpy(buf, p);

	return buf;
}

static EhArchive*
EhArchiveNew(char* name, char* rootdir)
{
	EhArchive* archive = EH_NEW(EhArchive);
	char pathbuf[MAXPATHLEN];

	make_relative_pathname(pathbuf, name, rootdir);

	archive->name = strdup(pathbuf);

	return archive;
}

#if 0
/*
 *    This is evil, we should never free anything, because it messes up
 *    interning.
 */
static void
EhSourceDelete(EhSource* source)
{
	unsigned n;
	if (source->name != NULL)
		free(source->name);
	if (source->directory != NULL)
		free(source->directory);
	if (source->cc_args != NULL) {
		for (n = 0; source->cc_args[n] != NULL; n++)
			free(source->cc_args[n]);
		free(source->cc_args);
	}
	if (source->as_savefile != NULL)
		free(source->as_savefile);
}
#endif

static EhSource*
EhSourceNew(char* name, char** cc_args, char* directory)
{
	EhSource* source = EH_NEW(EhSource);
	unsigned n;
	unsigned m;

	source->name = strdup(name);
	source->directory = (directory != NULL)? strdup(directory): NULL;
	source->as_savefile = NULL;
	source->compile_time = 0;
	source->target_object = NULL;
	source->cc_args = NULL;

	if (cc_args != NULL) {

		for (n = 0; cc_args[n] != NULL; n++)
			;

		source->cc_args = (char**)malloc(sizeof(char*) * (n+1));

		for (m = 0, n = 0; cc_args[n] != NULL;) {
			if (strcmp(cc_args[n], "-o") == 0 && cc_args[n+1] != NULL) {
				source->target_object = strdup(cc_args[n+1]);
				n += 2;
			} else {
				source->cc_args[m++] =  strdup(cc_args[n++]);
			}
		}

		source->cc_args[m] = NULL;
	}

	return source;
}

static EhObject*
EhObjectNewArchiveObject(EhArchive* archive, char* name)
{
	EhObject* object = EH_NEW(EhObject);

	if (name == eh_unnamed_object)
		object->name = name;
	else
		object->name = strdup(name);
	object->archive = archive;
	object->source = NULL;
	object->_recompile = NULL;
	object->_needs_unzap = 0;
	object->pathname = NULL;
	object->nusers = 0;

	return object;
}

static EhObject*
EhObjectNew(char* name, char* rootdir)
{
	EhObject* object = EhObjectNewArchiveObject(NULL, name);
	char pathname[MAXPATHLEN];

	make_relative_pathname(pathname, name, rootdir);
	object->pathname = strdup(pathname);

	return object;
}

static EhObject*
EhObjectNewFromSource(EhSource* source)
{
	EhObject* object = EhObjectNewArchiveObject(NULL, eh_unnamed_object);

	object->source = source;

	return object;
}

static char*
EhObjectGetFilename(EhObject* object, char* buf)
{
	if (object->archive) {
		strcpy(buf, object->archive->name);
		strcat(buf, ":");
		strcat(buf, object->name);
		return buf;
	} else {
		return object->name;
	}
}

static EhSym*
EhSymNewDefined(char* name, EhObject* object)
{
	EhSym* sym = EH_NEW(EhSym);

	sym->name = strdup(name);
	sym->object = object;
	sym->state = EH_SYM_DEFINED;
	sym->ngusers = 0;
	sym->nlusers = 0;

	return sym;
}

static EhSym*
EhSymNewInline(char* name)
{
	EhSym* sym = EhSymNewDefined(name, NULL);
	sym->state = EH_SYM_INLINE;

	return sym;
}

static EhSym*
EhSymNewUndefined(char* name)
{
	EhSym* sym = EhSymNewDefined(name, NULL);
	sym->state = EH_SYM_UNDEFINED;

	return sym;
}

static EhSym*
EhSymNewZapped(char* name, EhObject* object)
{
	EhSym* sym = EhSymNewDefined(name, object);
	sym->state = EH_SYM_ZAPPED;

	return sym;
}

static EhSym*
EhSymNewRandomZap(char* name)
{
	EhSym* sym = EhSymNewZapped(name, NULL);

	return sym;
}

EhSymTable*
EhSymTableNew(unsigned p_size)
{
	EhSymTable* table = EH_NEW(EhSymTable);

#ifdef USE_HASHING
	unsigned size;
	for (size = 0x1; size < (16*1024); size <<= 1) {
		if (size >= p_size)
			break;
	}
	table->size = size;
	table->heads = (EhSym**)calloc(size, sizeof(EhSym*));
#else
	table->head = NULL;
#endif
	table->nentries = 0;

	return table;
}

EhSym*
EhSymTableInsert(EhSymTable* table, EhSym* sym)
{
#ifdef USE_HASHING
	unsigned long hash = elf_hash(sym->name);
	unsigned long mask = table->size - 1;
	unsigned index = (hash & mask);

	sym->_next = table->heads[index];
	table->heads[index] = sym;
#else
	sym->_next = table->head;
	table->head = sym;
#endif
	table->nentries++;

	return sym;
}

EhSym*
EhSymTableFind(EhSymTable* table, char* name)
{
	EhSym* sym;
	EhSym* head;

#ifdef USE_HASHING
	unsigned long hash = elf_hash(name);
	unsigned long mask = table->size - 1;
	unsigned index = (hash & mask);
	head = table->heads[index];
#else
	head = table->head;
#endif

	for (sym = head; sym != NULL; sym = sym->_next) {
		if (strcmp(name, sym->name) == 0)
			break;
	}

	return sym;
}

typedef int (*eh_dump_mappee_t)(EhSym* sym, void* arg);

static int
EhSymTableMap(EhSymTable* table, eh_dump_mappee_t func, void* arg)
{
	EhSym* sym;
	EhSym* head;

#ifdef USE_HASHING
	unsigned n;
	for (n = 0; n < table->size; n++) {
		head = table->heads[n];
#else
		head = table->head; {
#endif
		for (sym = head; sym != NULL; sym = sym->_next) {
			if ((func)(sym, arg) == -1)
				return -1;
		}
	}

	return 0;
}

typedef struct {
	EhObject* o_old;
	EhObject* o_new;
} fixup_info;

static int
fixup_mappee(EhSym* sym, void* arg)
{
	fixup_info* info = (fixup_info*)arg;

	if (sym->object == info->o_old)
		sym->object = info->o_new;

	return 0;
}

static EhObject*
EhSymTableObjectFixup(EhSymTable* table, EhObject* o_old, EhObject* o_new)
{
	fixup_info info;

	/*
	 *    Now visit every sym that pointed to tmp, and point it
	 *    at object.
	 */
	info.o_old = o_old;
	info.o_new = o_new;
	EhSymTableMap(table, fixup_mappee, &info);
	
	return o_new;
}



static char*
safe_fgets(char* buf, unsigned size, FILE* fp)
{
	unsigned nread = 0;

	if (buf == NULL)
		buf = (char*)malloc(size);

	for (;;) {

		if (fgets(&buf[nread], size - nread, fp) == NULL) {
			free(buf);
			return NULL;
		}

		if (strchr(buf, '\n') != NULL)
			return buf;

		/*
		 *    fgets returns n-1 characters and \0
		 */
		nread += (size - nread) - 1;
		size += 1024;
		buf = (char*)realloc(buf, size);
	}
}

static int
EhSymTableSetSymbolState(EhSymTable* table, char* name, EhSymState new_state)
{
	EhSym* sym = EhSymTableFind(table, name);

	if (sym == NULL) {
		sym = EhSymNewDefined(name, NULL);

		EhSymTableInsert(table, sym);
	}

	/* new_state must be EH_SYM_DEFINED || EH_SYM_ZAPPED */
	if (sym->state == EH_SYM_DEFINED || sym->state == EH_SYM_ZAPPED) {
		sym->state = new_state;
	} else if (sym->state == EH_SYM_INLINE) {
		char* state_name;
		if (new_state == EH_SYM_DEFINED)
			state_name = "global";
		else
			state_name = "static";
		fprintf(stderr,
				"WARNING: Symbol %s is an inline.\n"
				"         Forcing the symbol %s will be ignored.\n",
				name,
				state_name);
	} else { /* EH_SYM_UNDEFINED */
		/*
		 *    This call is being made after objects have started being
		 *    read. This is too late. I'm not sure I care though.
		 */
		return -1;
	}

	return 0;
}

static int
EhSymTableFpLoad(EhSymTable* table, FILE* fp)
{
	char* buf = NULL; /* I hope this is big enough */
	char* p;
	char* name;
	char* state;
	EhSym* sym;
	EhSource* source = NULL;
	EhObject* object = NULL;
	char* cc_args[512];
	unsigned n;
	unsigned line_n = 0;
	char* ctime = NULL;
	char* directory;
	char* savefile;

	while ((buf = safe_fgets(buf, 1024, fp)) != NULL) {

		if ((p = strchr(buf, '\n')) == NULL) {
			fprintf(stderr, "line to long: %d\n", line_n);
			return -1;
		}
		*p = '\0';

		line_n++;

		if (buf[0] == '!') /* comment */
			continue;

		for (p = buf; isspace(*p); p++)
			;

		name = p;
		for (; !isspace(*p); p++)
			;
		*p++ = '\0';

		if (name[0] == '\0')
			continue;
		
		for (; isspace(*p); p++)
			;

		state = p;
		for (; !isspace(*p) && *p != '\0'; p++)
			;
		*p++ = '\0';

		if (state[0] == EH_TAG_GLOBAL
			||
			state[0] == EH_TAG_ZAPPED
			||
			state[0] == EH_TAG_INLINE) {
			sym = EhSymTableFind(table, name);
			if (sym == NULL) { /* install a new one */
				
				if (source == NULL && state[0] != EH_TAG_INLINE) {
					fprintf(stderr,
							"[%d] found new style symbol (%s) but no source\n",
							line_n, name);
				}

				if (state[0] == EH_TAG_GLOBAL)
					sym = EhSymNewDefined(name, object);
				else if (state[0] == EH_TAG_INLINE)
					sym = EhSymNewInline(name);
				else
					sym = EhSymNewZapped(name, object);
				
				EhSymTableInsert(table, sym);
			} else {
				if (state[0] == EH_TAG_GLOBAL) {
					if (sym->state != EH_SYM_DEFINED) {
						fprintf(stderr,
								"out of sync defined symbol: %s, fixing\n",
								sym->name);
						sym->state = EH_SYM_DEFINED;
					}
				} else if (state[0] == EH_TAG_INLINE) {
					if (sym->state != EH_SYM_INLINE) {
						fprintf(stderr,
								"out of sync inlined symbol: %s, fixing\n",
								sym->name);
						sym->state = EH_SYM_INLINE;
					}
				} else {
					if (sym->state != EH_SYM_ZAPPED) {
						fprintf(stderr,
								"out of sync zapped symbol: %s, fixing\n",
								sym->name);
						sym->state = EH_SYM_ZAPPED;
					}
				}

#if 0
				/* these are probably "special" symbols like .div */
				if (sym->object != object) {
					fprintf(stderr,
							"out of sync object for symbol: %s, ignoring\n",
							sym->name);
				}
#endif
			}

			continue; /* no more fields we care about */
		} else if (state[0] == EH_TAG_FILE) {

			directory = p;
			for (; !isspace(*p) && *p != '\0'; p++)
				;
			*p++ = '\0';

			savefile = p;
			for (; !isspace(*p) && *p != '\0'; p++)
				;
			*p++ = '\0';

			ctime = p;
			for (; !isspace(*p) && *p != '\0'; p++)
				;
			*p++ = '\0';

			for (n = 0; *p != '\0';) {

				for (; isspace(*p); p++)
					;
			
				cc_args[n++] = p++;
				
				for (; !isspace(*p) && *p != '\0'; p++)
					;
				
				if (*p == '\0')
					break;

				*p++ = '\0';
			}
			cc_args[n] = NULL;

			if (strcmp(directory, ".") == 0)
				directory = NULL;
			source = EhSourceNew(name, cc_args, directory);
			if (ctime != NULL)
				source->compile_time = (time_t)atoi(ctime);
			object = EhObjectNewFromSource(source);

		} else { /* old style symbol list */
			sym = EhSymTableFind(table, name);
			if (sym != NULL) {
				if (sym->state != EH_SYM_ZAPPED) {
					fprintf(stderr,
							"out of sync random zapped symbol: %s, fixing\n",
							sym->name);
					sym->state = EH_SYM_ZAPPED;
				}
			} else {
				sym = EhSymNewRandomZap(name);
			}
		}
	}

	return line_n;
}

typedef struct {
	EhSym**  vector;
	unsigned index;
} flush_info;

static int
flush_mappee(EhSym* sym, void* arg)
{
	flush_info* info = (flush_info*)arg;

	if (sym->state == EH_SYM_INLINE
		||
		(sym->object != NULL && sym->state == EH_SYM_DEFINED)
		||
		(sym->object != NULL && sym->state == EH_SYM_ZAPPED)) {
		if (info->vector != NULL)
			info->vector[info->index] = sym;
		info->index++;
	}

	return 0;
}

static  int
flush_compare(const void* ap, const void* bp)
{
	EhSym** ax = (EhSym**)ap;
	EhSym** bx = (EhSym**)bp;
	EhSym* a = *ax;
	EhSym* b = *bx;
	EhObject* oa = a->object;
	EhObject* ob = b->object;
	int foo;

	if (oa == NULL && ob != NULL)
		return -1;
	if (oa != NULL && ob == NULL)
		return 1;
	if (oa == NULL && ob == NULL) {
		foo = strcmp(a->name, b->name);
		if (foo < 0)
			return -1;
		else if (foo > 0)
			return 1;
		return 0;
	}

	if (oa->source == NULL && ob->source != NULL)
		return -1;
	if (oa->source != NULL && ob->source == NULL)
		return 1;
	if (oa->source == ob->source)
		return 0;
	if (oa->source < ob->source)
		return -1;
	if (oa->source > ob->source)
		return 1;
	foo = strcmp(a->name, b->name);
	if (foo < 0)
		return -1;
	else if (foo > 0)
		return 1;
	return 0;
}

static void
EhSourceFpWrite(EhSource* source, FILE* fp)
{
	unsigned n = 0;

	fputs(source->name, fp);
	fputc(' ', fp);
	fputc(EH_TAG_FILE, fp);

	fputc(' ', fp);
	if (source->directory != NULL)
		fprintf(fp, "%s", source->directory);
	else
		fputc('.', fp);
	
	fputc(' ', fp);
	if (source->as_savefile != NULL)
		fprintf(fp, "%s", source->as_savefile);
	else
		fputc('.', fp);
	
	fputc(' ', fp);
	fprintf(fp, "%d", source->compile_time);

	if (source->target_object != NULL) {
		fputs(" -o ", fp);
		fputs(source->target_object, fp);
	}
	
	if (source->cc_args != NULL) {
		for (n = 0; source->cc_args[n] != NULL; n++) {
			fputc(' ', fp);
			fputs(source->cc_args[n], fp);
		}
	}

	if (n < 1)
		fprintf(stderr, "WARNING: %s has no args\n", source->name);

	fputc('\n', fp);
}

static int
EhSymTableFpDump(EhSymTable* table, FILE* fp)
{
	flush_info info;
	unsigned n;
	EhObject* object = NULL;
	EhSym**   syms;
	EhSym*    sym;
	unsigned size;

	info.index = 0;
	info.vector = NULL;
	EhSymTableMap(table, flush_mappee, (void*)&info);
	size = info.index;

	syms = (EhSym**)malloc(sizeof(EhSym*) * size);
	info.index = 0;
	info.vector = syms;
	EhSymTableMap(table, flush_mappee, (void*)&info);

	/* sort */
	qsort(syms, size, sizeof(EhSym*), flush_compare);

	/* dump */
	for (n = 0; n < size; n++) {
		sym = syms[n];

		if (sym->object != object) {
			object = sym->object;

			if (object->source != NULL) {
				EhSourceFpWrite(object->source, fp);
			}
		}

		if (sym->state == EH_SYM_INLINE) {
			fprintf(fp, "%s %c\n", sym->name, EH_TAG_INLINE);
		} else if (object->source != NULL && sym->state == EH_SYM_ZAPPED) {
			fprintf(fp, "%s %c\n", sym->name, EH_TAG_ZAPPED);
		} else if (object->source != NULL && sym->state == EH_SYM_DEFINED) {
			fprintf(fp, "%s %c\n", sym->name, EH_TAG_GLOBAL);
		}
	}

	free(syms);

	return n;
}

int djw_debug;
char* djw_test_name;

int
eh_process_object(Elf* elf, EhObject* object, EhSymTable* table)
{
	Elf32_Shdr *   shdr;
	Elf32_Ehdr *   ehdr;
	Elf_Scn * scn;
	Elf_Data *     shstr_data;
	Elf_Data*      sym_data = NULL;
	Elf_Data*      str_data = NULL;
	Elf_Data*      rel_data[4];
	int            nrel_data = 0;
	Elf32_Rel*     rel_entries;
	Elf_Data*      rela_data[10];
	int            nrela_data = 0;
	Elf32_Rela*    rela_entries;
	unsigned int   cnt;
	Elf32_Sym* elf_sym;
	int i;
	int j;
	int k;
	char*  name;
	EhSym* sym;
	char buf[MAXPATHLEN];

	/* Obtain the .shstrtab data buffer */
	if (((ehdr = elf32_getehdr(elf)) == NULL) ||
		((scn = elf_getscn(elf, ehdr->e_shstrndx)) == NULL) ||
		((shstr_data = elf_getdata(scn, NULL)) == NULL)) {
		fprintf(stderr, "problems on %s\n", EhObjectGetFilename(object, buf));
		return -1;
	}

	/* get the string table */
	for (cnt = 1, scn = NULL; (scn = elf_nextscn(elf, scn)); cnt++) {
		if ((shdr = elf32_getshdr(scn)) == NULL) {
			fprintf(stderr, "problems on %s, section %d\n",
					EhObjectGetFilename(object, buf), cnt);
			return -1;
		}

#if 0
		fprintf(stderr, "%s: section %d type %d name %s\n",
				EhObjectGetFilename(object, buf),
				cnt,
				shdr->sh_type,
				(char*)shstr_data->d_buf + shdr->sh_name);
#endif

		/*
		 *    Get the string table.
		 */
		if (shdr->sh_type == SHT_STRTAB &&
#ifdef sun
			strcmp((char*)shstr_data->d_buf + shdr->sh_name, ".strtab") == 0 &&
#endif
			cnt != ehdr->e_shstrndx) {
			if (str_data != NULL) {
				fprintf(stderr, "multiple string tables for %s - bailing\n",
						EhObjectGetFilename(object, buf));
				return -1;
			}
			str_data = elf_getdata(scn, NULL);
		} else if (shdr->sh_type == SHT_SYMTAB) { /* look into sym table */
			if (sym_data != NULL) {
				fprintf(stderr, "multiple symbol tables for %s - bailing\n",
						EhObjectGetFilename(object, buf));
				return -1;
			}
			sym_data = elf_getdata(scn, NULL);
		} else if (shdr->sh_type == SHT_REL) { /* look into rel table */
			if (nrel_data >= 4) {
				fprintf(stderr, "too many relocation tables for %s bailing\n",
						EhObjectGetFilename(object, buf));
				return -1;
			}
			rel_data[nrel_data++] = elf_getdata(scn, NULL);
		} else if (shdr->sh_type == SHT_RELA) { /* look into rela table */
			if (nrela_data >= 10) {
				fprintf(stderr, "too many RELA tables for %s bailing\n",
						EhObjectGetFilename(object, buf));
				return -1;
			}
			rela_data[nrela_data++] = elf_getdata(scn, NULL);
		}
	}

	if (sym_data == NULL) {
		fprintf(stderr, "could not load sym table for %s\n",
				EhObjectGetFilename(object, buf));
		return -1;
	}

	if (str_data == NULL) {
		fprintf(stderr, "could not load string table for %s\n",
				EhObjectGetFilename(object, buf));
		return -1;
	}

	elf_sym = (Elf32_Sym*)sym_data->d_buf;

	for (i = 0; i < (sym_data->d_size/sizeof(Elf32_Sym)); i++) {

		/*
		 *    We are only interested in globals.
		 */
		if (ELF32_ST_BIND(elf_sym[i].st_info) != STB_GLOBAL)
			continue;
		
		name = (char *)str_data->d_buf + elf_sym[i].st_name;
		
		if (djw_test_name != NULL
			&& strcmp(djw_test_name, name) == 0) {
			printf("found %s\n", name);
		}
		
		sym = EhSymTableFind(table, name);
		
		/*
		 *    Treat inlines as non-globals
		 */
		if (sym != NULL && sym->state == EH_SYM_INLINE)
			continue;
		
#if 0
		printf("name = %s value = %d type = %d, info = %d,"
			   " other = %d, size = %d\n",
			   name,
			   elf_sym[i].st_value,
			   ELF32_ST_TYPE(elf_sym[i].st_info),
			   elf_sym[i].st_info,
			   elf_sym[i].st_other,
			   elf_sym[i].st_size);
#endif
		
		/* defined */
		if (ELFSYM_IS_DEFINED(elf_sym[i])) {
			
			if (sym != NULL) {
				
				if (sym->object == NULL) { /* object undefined */
					sym->object = object;
				} else if (sym->object->name==eh_unnamed_object) {
					
					if (object->source != NULL
						&&
						object->source != sym->object->source) {
						
						fprintf(stderr,
								"warning: symbol %s defined in more than one source file\n"
								"last time: %s\n"
								"this time: %s (ignored)\n",
								sym->name,
								object->source->name,
								sym->object->source->name);
					} else {
						object->source = sym->object->source;
						/*
						 *    Do a global: sym->object = object;
						 */
						EhSymTableObjectFixup(table,
											  sym->object, /*old*/
											  object); /*new*/
						
					}
					
				} else if (sym->object != object) {
					fprintf(stderr,
							"warning: symbol %s define in multiple object files\n"
							"last time: %s\n"
							"this time: %s (ignored)\n",
							sym->name,
							object->name,
							sym->object->name);
				}
				
				sym->state = EH_SYM_DEFINED;

			} else {
				sym = EhSymNewDefined(name, object);
				EhSymTableInsert(table, sym);
			}				

	        for (k = 0; k < nrel_data; k++) {
				int nentries = rel_data[k]->d_size/sizeof(Elf32_Rel);

				rel_entries = (Elf32_Rel*)rel_data[k]->d_buf;
				
				for (j = 0; j < nentries; j++) {
					if (ELF32_R_SYM(rel_entries[j].r_info) == i) {
						/* locally referenced */
						sym->nlusers++;
					}
				}
			}
	        for (k = 0; k < nrela_data; k++) {
				int nentries = rela_data[k]->d_size/sizeof(Elf32_Rela);

				rela_entries = (Elf32_Rela*)rela_data[k]->d_buf;
				
				for (j = 0; j < nentries; j++) {
					if (ELF32_R_SYM(rela_entries[j].r_info) == i) {
						/* locally referenced */
						sym->nlusers++;
					}
				}
			}
		}  
		
		/* Undefined. */
		else if (ELFSYM_IS_UNDEFINED(elf_sym[i])) {
			
			if (sym == NULL) {
				sym = EhSymNewUndefined(name);
				EhSymTableInsert(table, sym);
			}
			sym->ngusers++;
		} else {
			
#if 1
			printf("what is this: "
				   "name = %s value = %d type = %d, "
				   "info = %d, other = %d, size = %d\n",
				   name,
				   elf_sym[i].st_value,
				   ELF32_ST_TYPE(elf_sym[i].st_info),
				   elf_sym[i].st_info,
				   elf_sym[i].st_other,
				   elf_sym[i].st_size);
#endif
			;
		}/* type ==... */
	} /* for each symbol */

	return 0;
}

int
eh_process_file(char* filename, EhSymTable* table, char* rootdir)
{
	Elf* elf;
	Elf* arf;
	int  fd;
	Elf_Cmd cmd;
	Elf_Kind e_kind;
	EhObject* object;
	EhArchive* archive;
	Elf_Arhdr* arhdr;
	char* name;
	int   rv = 0;

	if ((fd = open(filename, O_RDONLY)) == -1) {
		fprintf(stderr, "error opening %s\n", filename);
		return -1;
	}

	elf_version(EV_CURRENT);
	if ((arf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
		return -1;
	}

	e_kind = elf_kind(arf);
	if (e_kind == ELF_K_ELF) {
		object = EhObjectNew(filename, rootdir);
		rv = eh_process_object(arf, object, table);
		
	} else if (e_kind == ELF_K_AR) {

		archive = EhArchiveNew(filename, rootdir);
		cmd = ELF_C_READ;

#if 0
		arsyms = elf_getarsym(arf, &narsyms);

		for (i = 0; i < narsyms && arsyms[i].as_name != NULL; i++) {
			printf("%s - %d\n", arsyms[i].as_name, arsyms[i].as_off);
		}

		arhdr = elf_getarhdr(arf);
		for (i = 0; arhdr[i].ar_rawname != NULL; i++) {

			if (arhdr[i].ar_name != NULL)
				printf("%s\n", arhdr[i].ar_name);
			else
				printf("[%s]\n", arhdr[i].ar_rawname);
		}
#endif

		rv = 0;

		while ((elf = elf_begin(fd, cmd, arf)) != 0) {

			e_kind = elf_kind(elf);

			if (e_kind != ELF_K_ELF)
				continue;

			arhdr = elf_getarhdr(elf);

			if (arhdr != NULL) {
				if (arhdr->ar_name != NULL)
					name = arhdr->ar_name;
				else
					name = arhdr->ar_rawname;
			} else {
				name = eh_unnamed_object;
			}

			object = EhObjectNewArchiveObject(archive, name);
			rv = eh_process_object(elf, object, table);

			if (rv == -1)
				break;

			cmd = elf_next(elf);
			elf_end(elf);
		}
	}

	elf_end(arf);

	close(fd);

	return rv;
}

static int
eh_dump_unused(EhSym* sym, void* arg)
{
	char buf[MAXPATHLEN];

	printf(/*"0x%x "*/ "%s %d %d ", /*sym,*/
		   sym->name, sym->ngusers, sym->nlusers);

	if (EHSYM_ISINLINE(sym))
		printf("%c ", EH_TAG_INLINE);
	else if (EHSYM_ISZAPPED(sym))
		printf("%c ", EH_TAG_ZAPPED);
	else if (EHSYM_ISDEFINED(sym))
		printf("%c ", EH_TAG_GLOBAL);
	else
		printf("%c ", EH_TAG_UNDEFINED);

	if (sym->object != NULL) {
		printf("%s ", EhObjectGetFilename(sym->object, buf));
		if (sym->object->source != NULL) {
			printf("%s recompilable\n", sym->object->source->name);
		} else {
			printf("nosource notrecompilable\n");
		}
	} else {
		printf("noobject nosource notrecompilable\n");
	}
	
	return 0;
}

static void
print_dump(EhSymTable* table)
{
	printf("everything\n");
	EhSymTableMap(table, eh_dump_unused, NULL);
}

typedef struct {
	unsigned ndefined;
	unsigned nused; /* globally */
	unsigned nundefined;
	unsigned nzapped;
	unsigned nzapped_nowused;
	unsigned ninlined;
	unsigned nunlinked;
	unsigned ndeadcode;
} SummaryInfo;

static int
eh_summary_mappee(EhSym* sym, void* arg) {
	SummaryInfo* info = (SummaryInfo*)arg;

	if (EHSYM_ISDEFINED(sym)) {
		if (sym->ngusers != 0)
			info->nused++;
		else if (sym->object != NULL && sym->object->nusers == 0)
			info->nunlinked++;
		else if (sym->nlusers != 0)
			info->ndefined++;
		else
			info->ndeadcode++;
			
	} else if (EHSYM_ISZAPPED(sym)) { /* one of ours */
		if (sym->ngusers != 0)
			info->nzapped_nowused++;
		else
			info->nzapped++;
	} else if (EHSYM_ISINLINE(sym)) { /* one of ours */
		info->ninlined++;
	} else {
		info->nundefined++;
	}

	return 0;
}

static void
get_summary(EhSymTable* table, SummaryInfo* info)
{
	info->ndefined = 0;
	info->nused = 0;
	info->nundefined = 0;
	info->nzapped = 0;
	info->nzapped_nowused = 0;
	info->ninlined = 0;
	info->nunlinked = 0;
	info->ndeadcode = 0;
	
	EhSymTableMap(table, eh_summary_mappee, info);
} 

static void
print_summary(EhSymTable* table)
{
	SummaryInfo info;

	get_summary(table, &info);
	
	printf("summary:\n"
		   "defined and used:             %d\n"
		   "defined but unused globally:  %d\n"
		   "total globals in target:      %d\n"
		   "--------------------------------\n"
		   "global to statics *:          %d\n"
		   "global to statics (now used): %d\n"
		   "inlined to statics *:         %d\n"
		   "defined in unlinked objects:  %d\n"
		   "defined but unused (deadcode):%d\n"
		   "undefined but used:           %d\n",
		   info.nused,
		   info.ndefined,
		   (info.nused + info.ndefined),
		   info.nzapped,
		   info.nzapped_nowused,
		   info.ninlined,
		   info.nunlinked,			   
		   info.ndeadcode,			   
		   info.nundefined);
}

typedef struct EhDirMapEntree {
	char* dirname;
	struct EhDirMapEntree* _next;
} EhDirMapEntree;

typedef struct EhDirMap {
	EhDirMapEntree* head;
} EhDirMap;

static EhDirMap*
EhDirMapNew(void)
{
	EhDirMap* dm = EH_NEW(EhDirMap);
	dm->head = NULL;
	return dm;
}

static void
EhDirMapAddDirectory(EhDirMap* map, char* dirname)
{
	EhDirMapEntree* entree = EH_NEW(EhDirMapEntree);
	EhDirMapEntree* foo;

	entree->dirname = strdup(dirname);
	entree->_next = NULL;

	if (map->head == NULL) {
		map->head = entree;
	} else {
		for (foo = map->head; foo->_next != NULL; foo = foo->_next)
			;

		foo->_next = entree;
	}
}

static char*
EhDirMapGetLibName(EhDirMap* map, char* name, char* libbuf)
{
	EhDirMapEntree* foo;
	struct stat     buf;

	for (foo = map->head; foo != NULL; foo = foo->_next) {
		sprintf(libbuf, "%s/lib%s.a", foo->dirname, name);

		if (stat(libbuf, &buf) != -1)
			return libbuf;
	}

	return NULL;
}

static char*
test_for_global(char* buf)
{
#ifdef IRIX
	if (strncmp(buf, "\t.globl\t", 8) == 0)
		return &buf[8];
#else
	if (strncmp(buf, "\t.global ", 9) == 0)
		return &buf[9];
#endif
	return NULL;
}

static char*
test_for_file(char* foo, char* buf)
{
#ifdef IRIX
	char* p;
	char* q;
	if (strncmp(buf, "\t.file\t", 6) == 0) {
		for (p = &buf[6]; *p != '"' && *p != '\0'; p++)
			;
		if (*p == '\0')
			return NULL;
		p++; /* quote */
		q = strchr(p, '"');
		if (q == NULL)
			return NULL;
		memcpy(foo, p, q - p);
		foo[q - p] = '\0';
		return foo;
	}
#else
	printf("test_for_file() not implimented\n");
#endif
	return NULL;
}

static int
EhSourceZapFp(EhSource* source, EhSymTable* table, FILE* fpi, FILE* fpo,
			  unsigned verbosity, unsigned cplusplus)
{
	char*     buf = NULL;
	char*     p;
	int       nzap = 0;
	char*     name;
	EhSym*    sym;
	int       i_zapped;
	EhObject* object = EhObjectNewFromSource(source);
	char*     filename = source->name;
	char*     tmp_name;
	char      foo[256];
	unsigned  line_n = 0;

	if (VERBOSITY_DEBUG(verbosity))
		fputs("gts: ", stderr);

	while ((buf = safe_fgets(buf, 4192, fpi)) != NULL) {

		i_zapped = 0;
		for (p = buf; *p != '\0' && *p != '\n'; p++)
			;
		*p = '\0';

		if ((tmp_name = test_for_file(foo, buf)) != NULL) {
			if (strcmp(tmp_name, filename) != 0) /* not the same file */
				filename = "non local file";
			else
				filename = source->name;
		}

		else if ((name = test_for_global(buf)) != NULL) {

			sym = EhSymTableFind(table, name);

			/* an inline, we have to treat specially */
			if ((filename != source->name && cplusplus != 0) /* inline now */
				||
				(sym != NULL && sym->state == EH_SYM_INLINE)) {/* was inline */

				if (!sym) { 

					sym = EhSymNewInline(name);
					
					EhSymTableInsert(table, sym);
				}
				sym->state = EH_SYM_INLINE; /* just make sure */

				if (fpo != NULL) /* always zap inlines we see */
					fputs(" # gts", fpo);

			} else { /* a real global */

				if (fpo != NULL && sym != NULL && EHSYM_ISZAPPED(sym)) {
					if (VERBOSITY_DEBUG(verbosity)) {
						fprintf(stderr, "%s ", &buf[8]);
					}
					nzap++;

					if (fpo != NULL)
						fputs(" # gts", fpo);
				}

				if (sym != NULL) {
					if (sym->object == NULL) {
						sym->object = object;
					} else if (sym->object != object) {
						sym->object->source = source;
						EhSymTableObjectFixup(table, object, sym->object);
						object = sym->object;
					}
				} else { /* install a new one */
					
					sym = EhSymNewDefined(name, object);
					
					EhSymTableInsert(table, sym);
				}

			}
		}

		if (fpo != NULL) {
			fputs(buf, fpo);
			fputc('\n', fpo);
		}
		line_n++;
	}
	
	if (VERBOSITY_DEBUG(verbosity))
		fputc('\n', stderr);

	return nzap;
}

static void
print_command(char* command, char** args, unsigned verbosity)
{
	int i;
	FILE* fp = stderr;
	if (!VERBOSITY_USER(verbosity))
		return;

	fprintf(fp, "%s: ", command);
	for (i = 0; args[i]; i++) {
		fprintf(fp, "%s ", args[i]);
	}
	fprintf(fp, "\n");
}

static int
do_command(char* label, char** args, unsigned verbosity)
{
	int status;
	pid_t child_pid;
	char* file = args[0];

	print_command(label, args, verbosity);

	if ((child_pid = fork()) == -1) {
		fprintf(stderr, "could not fork: ");
		perror(NULL);
		return -1;
	}

	if (child_pid == 0) { /* i am the child */
		if (execvp(file, args) == -1) {
			fprintf(stderr, "could not exec %s: ", file);
			perror(NULL);
			exit(3);
		}
		/*NOTREACHED*/
	}

	if (waitpid(child_pid, &status, 0) == -1) {
		fprintf(stderr, "wait on %s failed: ", file);
		perror(NULL);
		return -1;
	}

	return WEXITSTATUS(status);
}

static char*
suffix_name(char* s)
{
	char* p;

	if ((p = strrchr(s, '.')) != NULL)
		return p;
	else
		return "";
}

static char base_name_buf[MAXPATHLEN];

static char*
base_name(char* s)
{
	char* p;

	if ((p = strrchr(s, '.')) != NULL) {
		memcpy(base_name_buf, s, p - s);
		base_name_buf[p - s] = '\0';
		s = base_name_buf;
	}
	return s;
}

static char*
file_base_name(char *s)
{
	char* p;

	s = base_name(s);

	if ((p = strrchr(s, '/')) != NULL)
		s = &p[1];
	
	return s;
}
static int
EhSourceCompile(EhSource*   source,
				EhSymTable* table,
				unsigned    verbosity,
				unsigned    do_compile,
				unsigned    do_zap,
				unsigned    do_assem)
{
	char* filename = source->name;
	char** opts = source->cc_args;
	char asname[MAXPATHLEN];
	char o_asname[MAXPATHLEN];
	char* cc_opts[256];
	unsigned i = 0;
	unsigned j = 0;
	FILE* in_fp;
	FILE* out_fp;
	int   status;
	int nzap = 0;
	char* save_prefix = NULL;
	unsigned do_dash_s = (do_zap != 0 || save_prefix != NULL);
	char* cc_command;
	char* use_savefile = NULL;
	struct timeval start_time;
	struct timeval end_time;
#ifdef DEBUG_djw
	char savebuf[1024];
#endif
	unsigned is_cplusplus = 0;

#ifdef LINUX
	gettimeofday(&start_time,NULL);
#else
	gettimeofday(&start_time);
#endif

	/* munge file */
#ifdef HANDLES_DASHSO
	if (source->target_object != NULL)
		strcpy(asname, base_name(source->target_object));
	else
#endif
		strcpy(asname, file_base_name(filename));
	strcat(asname, ".s");

	strcpy(o_asname, asname);
	strcat(o_asname, ".gts_tmp");

	if (strcmp(suffix_name(filename), ".cpp") == 0) {
		cc_command = CCC_COMMAND;
		is_cplusplus = 1;
	} else if (strcmp(suffix_name(filename), ".s") == 0) {
		do_compile = FALSE;
		cc_command = CC_COMMAND;
	} else {
		cc_command = CC_COMMAND;
	}

	if (do_compile) {

		j = 0;
		cc_opts[j++] = cc_command;
		cc_opts[j++] = "-c";

		if (do_dash_s) {
			cc_opts[j++] = "-S";
#ifdef HANDLES_DASHSO
			if (source->target_object != NULL) {
				cc_opts[j++] = "-o";
				cc_opts[j++] = asname;
			}
#endif
		} else if (source->target_object != NULL) {
			cc_opts[j++] = "-o";
			cc_opts[j++] = source->target_object;
		}
		
		i = 0;
		while (opts[i] != NULL)
			cc_opts[j++] = opts[i++];
		
		cc_opts[j++] = filename;
		cc_opts[j] = NULL;
		
		if ((status = do_command("compile", cc_opts, verbosity)) != 0) {
			fprintf(stderr, "compile failed (returned %d)\n", status);
			return -1;
		}

		if (!do_dash_s)
			return 0;
	}

	/*
	 *    Now we have a foo.s file, what do we do with it?
	 */
	if (do_zap > 1) {

		if (use_savefile == NULL)
			use_savefile = asname;

		if ((in_fp = fopen(use_savefile, "r")) == NULL) {
			fprintf(stderr, "could not open %s for reading\n", asname);
			return -1;
		}
	
		if ((out_fp = fopen(o_asname, "w")) == NULL) {
			fprintf(stderr, "could not open %s for writing\n", o_asname);
			return -1;
		}
	
		j = 0;
		cc_opts[j++] = "gts";
		cc_opts[j++] = asname;
		cc_opts[j++] = o_asname;
		cc_opts[j++] = NULL;
		print_command("gts", cc_opts, verbosity);

		nzap = EhSourceZapFp(source, table, in_fp, out_fp, verbosity, is_cplusplus);

		fclose(in_fp);
		fclose(out_fp);

		j = 0;
		cc_opts[j++] = "rename";
		cc_opts[j++] = o_asname;
		cc_opts[j++] = asname;
		cc_opts[j++] = NULL;
		print_command("rename", cc_opts, verbosity);

#ifdef DEBUG_djw
		strcpy(savebuf, "gts_pre_");
		strcat(savebuf, asname);
		rename(asname, savebuf);
#endif

		if (rename(o_asname, asname) == -1) {
			fprintf(stderr, "could not rename %s\n", o_asname);
			return -1;
		}

	} else if (do_zap > 0) { /* audit only */

		if ((in_fp = fopen(asname, "r")) == NULL) {
			fprintf(stderr, "could not open %s for reading\n", asname);
			return -1;
		}
	
		j = 0;
		cc_opts[j++] = "audit";
		cc_opts[j++] = asname;
		cc_opts[j++] = NULL;
		print_command("audit", cc_opts, verbosity);

		nzap = EhSourceZapFp(source, table, in_fp, NULL, verbosity, is_cplusplus);

		fclose(in_fp);
	}

	if (do_assem) {
		i = 0;
		j = 0;
		cc_opts[j++] = AS_COMMAND;
		cc_opts[j++] = "-c";

		if (source->target_object != NULL) {
			cc_opts[j++] = "-o";
			cc_opts[j++] = source->target_object;
		}

		while (opts[i] != NULL)
			cc_opts[j++] = opts[i++];

		cc_opts[j++] = asname;
		cc_opts[j] = NULL;

		if ((status = do_command("assemble", cc_opts, verbosity)) != 0) {

			unlink(asname);

			fprintf(stderr,
				"gtscc of %s failed (exit status = %d), reverting to %s:\n",
					filename,
					status,
					cc_command);
			
			i = 0;
			j = 0;
			cc_opts[j++] = cc_command;
			cc_opts[j++] = "-c";

			if (source->target_object != NULL) {
				cc_opts[j++] = "-o";
				cc_opts[j++] = source->target_object;
			}

			for (; opts[i]; i++, j++)
				cc_opts[j] = opts[i];
			
			cc_opts[j++] = filename;
			cc_opts[j] = NULL;
			
			if ((status = do_command("fix-compile", cc_opts, verbosity)) != 0)
				return -1;

			return 0;
		}
	}

	if (save_prefix != NULL && save_prefix[0] != '\0') {

		sprintf(o_asname, save_prefix, file_base_name(filename));

		j = 0;
		cc_opts[j++] = "rename";
		cc_opts[j++] = asname;
		cc_opts[j++] = o_asname;
		cc_opts[j++] = NULL;
		print_command("savefile", cc_opts, verbosity);

		if (rename(asname, o_asname) == -1) {
			fprintf(stderr, "could not rename %s to %s - sorry\n",
					asname, o_asname);
			return -1;
		}

		if (source->as_savefile != NULL)
			free(source->as_savefile);
		source->as_savefile = strdup(o_asname);
	} else {

		j = 0;
		cc_opts[j++] = "unlink";
		cc_opts[j++] = asname;
		cc_opts[j++] = NULL;
		print_command("unlink", cc_opts, verbosity);

#ifdef DEBUG_djw
		strcpy(savebuf, "gts_post_");
		strcat(savebuf, asname);
		rename(asname, savebuf);
#else
		unlink(asname);
#endif
	}

#ifdef LINUX
	gettimeofday(&end_time,NULL);
#else
	gettimeofday(&end_time);
#endif

	source->compile_time = ((end_time.tv_sec - start_time.tv_sec) * 1000) +
                           ((end_time.tv_usec - start_time.tv_usec) / 1000);

	return nzap;
}

static char target_buf[MAXPATHLEN]; /* this will go away with rel source */

static char*
EhSourceGetTarget(EhSource* source)
{
	if (source->target_object != NULL)
		return source->target_object;

	strcpy(target_buf, base_name(source->name));
	strcat(target_buf, ".o");

	return target_buf;
}

static int
EhArchiveUpdate(EhArchive* archive, char* target, char* rootdir,
				unsigned verbosity)
{
	char* args[8];
	unsigned nargs;
	int status;
	char pathname[MAXPATHLEN];

	pathname[0] = '\0';
	if (rootdir != NULL) {
		strcat(pathname, rootdir);
		strcat(pathname, "/");
	}
	strcat(pathname, archive->name);

#if 0
	nargs = 0;
	args[nargs++] = AR_COMMAND;
	args[nargs++] = "dc";
	args[nargs++] = pathname;
	args[nargs++] = target;
	args[nargs++] = NULL;
	
	if ((status = do_command("delete from archive", args, verbosity)) != 0) {
		fprintf(stderr, "archive: %s delete %s failed (status = %d)\n",
				pathname,
				target);
		return -1;
	}
#endif

	nargs = 0;
	args[nargs++] = AR_COMMAND;
	args[nargs++] = AR_OPTIONS;
	args[nargs++] = pathname;
	args[nargs++] = target;
	args[nargs++] = NULL;
	
	if ((status = do_command("archive", args, verbosity)) != 0) {
		fprintf(stderr, "archive: %s <- %s failed (status = %d)\n",
				pathname,
				target);
		return -1;
	}

	return 0;
}

static int
EhObjectRebuild(EhObject*   object,
				EhSymTable* table,
				unsigned    verbosity,
				char*       rootdir)
{
	EhSource* source = object->source;
	char  cwd[MAXPATHLEN];
	char  fullpath[MAXPATHLEN];
	int   rv = 0;
	int   do_chdir = 0;

	if (!source) {
		fprintf(stderr,
				"wanted to recompile %s, but I don't how\n",
				object->name);
		return -1;
	}
	
#if 0
	if (VERBOSITY_USER(verbosity))
#endif
		fprintf(stderr, "recompiling %s\n", source->name);
	
	/*
	 *    Check to see if we need to chdir
	 */
	if (source->directory != NULL) {
		if (getcwd(cwd, sizeof(cwd)) == NULL) {
			fprintf(stderr, "cannot get pwd: cannot compile\n");
			return -1;
		}
		
		make_relative_pathname(fullpath, cwd, rootdir);
		
		if (strcmp(fullpath, source->directory) != 0) {
			fullpath[0] = '\0';
			if (rootdir != NULL) {
				strcat(fullpath, rootdir);
				strcat(fullpath, "/");
			}
			strcat(fullpath, source->directory);

			if (chdir(fullpath) == -1) {
				fprintf(stderr, "cannot chdir - can't compile\n");
				return -1;
			}
			do_chdir++;
		}
	}

	rv = EhSourceCompile(source,
						 table,
						 verbosity,
						 TRUE,  /* compile  */
						 2,     /* do zap   */
						 TRUE); /* do assem */

	if (do_chdir) {
		if (chdir(cwd) == -1) {
			fprintf(stderr, "cannot chdir - this will be very confused\n");
			return -1;
		}
	}

	if (rv == -1) {
		fprintf(stderr, "recompiling %s failed\n",  source->name);
		return -1;
	}
	
	/* do archive */
	fullpath[0] = '\0';
	if (rootdir != NULL) {
		strcat(fullpath, rootdir);
		strcat(fullpath, "/");
	}

	if (source->directory != NULL)
		strcat(fullpath, source->directory);

	strcat(fullpath, "/");
	strcat(fullpath, EhSourceGetTarget(source));
	
	if (object->archive != NULL) {
		if (EhArchiveUpdate(object->archive, fullpath, rootdir,
							verbosity) == -1)
			return -1;
	}

	/* do install */
#if 0
	if (rv != -1) {
	}
#endif

	return rv;
}

static int
object_nusers_mappee(EhSym* sym, void* arg)
{
	if (sym->object != NULL)
		sym->object->nusers += sym->ngusers;
	return 0;
}

typedef struct {
	EhObject* recompile_list;
	unsigned  recompile_count;
	unsigned  recompile_wish_count;
	unsigned  unzap_count;
	unsigned  zap_count;
} RecompileInfo;

static int
recompile_init_mappee(EhSym* sym, void* arg)
{
	RecompileInfo* info = (RecompileInfo*)arg;

	if (EHSYM_ISZAPPED(sym) && sym->ngusers != 0) {
		if (EH_OBJECT_CANBUILD(sym->object)) {
			sym->state = EH_SYM_DEFINED;
			if (sym->object->_recompile == NULL) {
				sym->object->_recompile = info->recompile_list;
				info->recompile_list = sym->object;
				info->recompile_count++;
			}
			info->unzap_count++;
			sym->object->_needs_unzap++;
		}
		info->recompile_wish_count++;
	}
	else if (EHSYM_ISDEFINED(sym) /* it's defined */
			 && sym->ngusers == 0 /* there are no global users */
			 && sym->nlusers != 0 /* BUT, ther are local users */
			 && sym->object->nusers != 0) { /* object is linked */

		if (EH_OBJECT_CANBUILD(sym->object)) {
			sym->state = EH_SYM_ZAPPED;
			if (sym->object->_recompile == NULL) {
				sym->object->_recompile = info->recompile_list;
				info->recompile_list = sym->object;
				info->recompile_count++;
			}
			info->zap_count++;
		}
		info->recompile_wish_count++;
	}

	return 0;
}

static char**    recompile_compare_prefs;
static char**    recompile_compare_unprefs;

static unsigned
match_prefs(char* candidate, char** prefs)
{
	unsigned n;

	for (n = 0; prefs[n] != NULL; n++) {
		char*    pref = prefs[n];
		unsigned len = strlen(pref);
		if (strncmp(pref, candidate, len) == 0)
			return n; /* cool */
	}
	return (unsigned)-1; /* big! */
}

static  int
recompile_compare(const void* ap, const void* bp)
{
	EhObject** ax = (EhObject**)ap;
	EhObject** bx = (EhObject**)bp;
	EhObject*  obj_a = *ax;
	EhObject*  obj_b = *bx;
	EhSource*  src_a = obj_a->source;
	EhSource*  src_b = obj_b->source;
	unsigned   matcha;
	unsigned   matchb;
	int        foo;

	if (obj_a->_needs_unzap == 0 && obj_b->_needs_unzap != 0)
		return -1;
	if (obj_a->_needs_unzap != 0 && obj_b->_needs_unzap == 0)
		return 1;

	if (src_a == NULL && src_b != NULL)
		return 1;
	if (src_a != NULL && src_b == NULL)
		return -1;
	if (src_a == src_b)
		return 0;

	if (recompile_compare_unprefs != NULL
		&& src_a->directory != NULL && src_b->directory != NULL) {

		matcha = match_prefs(src_a->directory, recompile_compare_unprefs);
		matchb = match_prefs(src_b->directory, recompile_compare_unprefs);

		if (matcha > matchb) /* greater is good */
			return -1;
		if (matcha < matchb)
			return 1;
	}

	if (recompile_compare_prefs != NULL
		&& src_a->directory != NULL && src_b->directory != NULL) {

		matcha = match_prefs(src_a->directory, recompile_compare_prefs);
		matchb = match_prefs(src_b->directory, recompile_compare_prefs);

		if (matcha > matchb) /* greater is bad */
			return 1;
		if (matcha < matchb)
			return -1;
	}

	/* else same directory probably */
	foo = strcmp(src_a->name, src_b->name);

	if (foo < 0)
		return -1;
	if (foo > 0)
		return 1;

	return 0;
}

static int
do_recompilation(EhSymTable* table, char* gts_file, unsigned max_globals,
				 char** prefs, char** unprefs,
				 char* rootdir, unsigned verbosity)
{
	SummaryInfo s_info;
	RecompileInfo info;
	unsigned    size;
	unsigned n;
	EhObject* object;
	EhObject** recompiles;
	unsigned delta;
	int rv;
	unsigned nzaps;
	EhObject dummy; /* just marks the end of the recomp list */
	time_t  eta;

	get_summary(table, &s_info);

	if ((s_info.nused + s_info.ndefined) <= max_globals) {
		if (VERBOSITY_USER(verbosity))
			fprintf(stderr,
			"number of globals <= requested max, skipping recompilation\n");
		return 0;
	}

	/* Init recompilation. */
	info.recompile_list = &dummy; /* cannot use NULL, because syms test that */
	info.recompile_count = 0;
	info.recompile_wish_count = 0;
	info.unzap_count = 0;
	info.zap_count = 0;
	EhSymTableMap(table, recompile_init_mappee, (void*)&info);
	size = info.recompile_count;

	recompiles = (EhObject**)malloc(sizeof(EhObject*) * size);

	/* install */
	n = 0;
	for (object = info.recompile_list;
		 object != &dummy;
		 object = object->_recompile) {
		recompiles[n++] = object;
	}

	/* sort */
	recompile_compare_prefs = prefs;
	recompile_compare_unprefs = unprefs;
	qsort(recompiles, size, sizeof(EhObject*), recompile_compare);

	/*
	 *    sorted !
	 *    less recompile the first n, n = ndefined - max
	 */
	delta = (s_info.nused + s_info.ndefined) - max_globals;

	if (delta > info.zap_count) {
		fprintf(stderr,
				"WARNING: there too many globals (%d/%d fixables).\n"
				"         I don't think I can fix this, but I'll try.\n"
				"         You might get lucky.\n",
				info.zap_count,
				delta);
	}

	if (VERBOSITY_USER(verbosity))
		fprintf(stderr, "scheduling recompilation targets:\n");

	eta = 0;
	for (n = 0; n < size; n++) {
		char* cname = "unknown";
		object = recompiles[n];
		if (object->source != NULL) {
			cname = object->source->name;
			eta += object->source->compile_time;
		}
		
		if (VERBOSITY_DEBUG(verbosity))
			fprintf(stderr, "object %s from source %s\n", object->name, cname);
	}

#if 0
	if (VERBOSITY_USER(verbosity))
#endif
		fprintf(stderr, "gts-ing %d symbols, eta = %d minutes\n", delta,
				eta/(60*1000));

	if (gts_file != NULL) {
		FILE* zap_fp;
		if ((zap_fp = fopen(gts_file, "w")) == NULL) {
			perror(0);
			fprintf(stderr,
					"WARNING: could not open the gtscc db file %s.\n"
					"         I will continue with the recompilation, but\n"
					"         if you recompile any of the files I touched\n"
					"         I'll have to recompile them after you!\n",
					gts_file);
		} else {
		
			EhSymTableFpDump(table, zap_fp);
			
			fclose(zap_fp);
		}
	}

	for (n = 0, nzaps = 0; n < size && nzaps < delta; n++) {

		object = recompiles[n];
		rv = EhObjectRebuild(object, table, verbosity, rootdir);

		if (rv == -1)
			return -1;

		nzaps += rv;

		object->_recompile = NULL; /* clean up now */
	}

	if (nzaps < delta) {
		fprintf(stderr,
				"WARNING: I wanted to gts %d symbols, but only managed\n"
				"         to get %d of them.\n"
				"         Your link may fail with GOT errors.\n",
				delta,
				nzaps);
	}
	
	free(recompiles);

	return n;
}

typedef struct FileList
{
	char*            name;
	struct FileList* next;
} FileList;

static FileList*
fileListFind(FileList* list, char* name)
{
	FileList* foo;

	for (foo = list; foo != NULL; foo = foo->next) {
		if (strcmp(name, foo->name) == 0)
			return foo;
	}
	return NULL;
}

static FileList*
fileListAppend(FileList** list_a, char* name)
{
	FileList* list = *list_a;
	FileList* foo;
	FileList* last;

	for (foo = list, last = NULL; foo != NULL; last = foo, foo = foo->next)
		;

	if (last == NULL) {
		foo = EH_NEW(FileList);
		foo->next = NULL;
		foo->name = strdup(name);
		*list_a = foo;
	} else {
		foo = EH_NEW(FileList);
		foo->next = NULL;
		foo->name = strdup(name);
		last->next = foo;
	}

	return *list_a;
}

#if 0
static FileList* c_list;
#endif
static FileList* o_list;

#if 0
static char*
EhSourceAdjustPathname(EhSource* source, char* rootdir)
{
	char buf[MAXPATHLEN];
	char buf2[MAXPATHLEN];
	char* p;
	char* q;
	char* filename = source->name;

	if (getcwd(buf, sizeof(buf)) == NULL) {
		fprintf(stderr, "cannot get pwd\n");
		return NULL;
	}

	strcat(buf, "/");
	strcat(buf, filename);

	if (rootdir == NULL) {
		filename = buf;
	} else {
		if (realpath(buf, buf2) == NULL) {
			fprintf(stderr, "realpath() failed: %s\n", buf2);
			return NULL;
		}

		if (realpath(rootdir, buf) == NULL) {
			fprintf(stderr, "realpath() failed: %s\n", buf);
			return NULL;
		}
		strcat(buf, "/"); 
		
		for (p = buf, q = buf2; *p == *q; p++, q++)
			;

		filename = q;
	}

	free(source->name);
	source->name = strdup(filename);

	return source->name;
}
#endif

static unsigned
katoi(char *buf)
{
	unsigned base = 1;
	char* s;
	
	for (s = buf; isdigit(*s); s++)
		;

	if (*s == 'k' || *s == 'K')
		base = 1024;

	*s = '\0';

	return base * atoi(buf);
}

static void
usage(void)
{
	fprintf(stderr,
			"Usage:\n"
			"as a compiler:\n"
			"gtscc [gtscc_options] [compiler_options] -c file.c file.cpp ...\n"
			"gtscc_options:\n"
			"-gtsfile <db.gts>       the gts database file (use this)\n"
			"-gtszapsymbol <name>    convert symbol <name>\n"
			"-gtsnozapsymbol <name>  don't convert symbol <name>\n"
			"-gtsrootdir <directory> the root for the tree (use this)\n"
			"-gtsverbose             be more verbose (3 levels)\n"
			"-gtsnozap               don't convert globals to statics\n"
			"-gtsnoupdate            don't update the database file\n"
			"as a linker:\n"
			"gtscc [gtscc_options] [linker_options] file.o ... libxx.a ...\n"
			"gtscc_options:\n"
			"-gtsfile <db.gts>       the gts database file (use this)\n"
			"-gtszapsymbol <name>    convert symbol <name>\n"
			"-gtsnozapsymbol <name>  don't convert symbol <name>\n"
			"-gtsrootdir <directory> the root for the tree (use this)\n"
			"-gtspref <directory>    please recompile these paths first\n"
			"-gtsunpref <directory>  please try to avoid recompiling these\n"
			"-gtsverbose             be more verbose (3 levels)\n"
			"-gtssummary             print a summary of global usage\n"
			"-gtsdump                print a detailed listing of all symbols\n"
			"-gtsmaxglobals <number>[k] maximum globals allowed in target\n"
			"-gtsnorecompile         don't do the normal recompilation\n"
			"-gtsnolink              don't call linker after recompilation\n"
			"-gtsnoupdate            don't update the database file\n"
			"-help                   print this\n"
	);
}

int
main(int argc, char** argv)
{
	EhSymTable* table = EhSymTableNew(1000);
	EhSym* sym;
	FILE* zap_fp;
	unsigned n = 0;
	unsigned verbosity = 0;
	char* arg_buf[256];
	unsigned nargs = 0;
	EhDirMap*   dmap = EhDirMapNew();
	unsigned do_dump = 0;
	unsigned do_summary = 0;
	unsigned do_link = 1;
	unsigned in_link = 1;
	unsigned do_audit = 1;
	unsigned do_zap = 1;
	unsigned do_assem = 1;
	unsigned do_recompile = 1;
	unsigned do_collect = 1;
	char* name;
	char* saveprefix = NULL;
	char* rootdir = NULL;
	int rv;
	EhSource* source = NULL;
	char* gts_file = NULL;
	char* path_prefs[32];
	unsigned npath_prefs = 0;
	char* path_un_prefs[32];
	unsigned npath_un_prefs = 0;
	char* suffix;
	unsigned max_globals = DEFAULT_MAX_GLOBALS;
	FileList* list;

	if (elf_version(EV_CURRENT) == EV_NONE) {
		fprintf(stderr, "something losing about your elf lib - sorry!\n");
		return 3;
		/* library out of date */
		/* recover from error */
	}

	arg_buf[nargs] = NULL;

	for (n = 1; n < argc; n++) {

		if (strcmp(argv[n], "-help") == 0) {
			usage();
			return 0;
		} else if (strcmp(argv[n], "-gtssummary") == 0) {
			do_summary = 1;
		} else if (strcmp(argv[n], "-gtsdump") == 0) {
			do_dump = 1;
		} else if (strcmp(argv[n], "-gtsnorecompile") == 0) {
			do_recompile = 0;
		} else if (strcmp(argv[n], "-gtsnolink") == 0) {
			do_link = 0;
		} else if (strcmp(argv[n], "-gtsverbose") == 0) {
			verbosity++;
		} else if (strcmp(argv[n], "-gtsnoupdate") == 0) {
			do_collect = 0;
		} else if (strcmp(argv[n], "-gtsnoaudit") == 0) {
			do_audit = 0;
		} else if (strcmp(argv[n], "-gtsnozap") == 0) {
			do_zap = 0;
		} else if (strcmp(argv[n], "-gtsrootdir") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtsrootdir requires an argument\n");
				usage();
				return 2;
			}
			rootdir = argv[n+1];
			n++;
		} else if (strcmp(argv[n], "-gtsdebugsym") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtsdebugsym requires an argument\n");
				usage();
				return 2;
			}
			djw_test_name = argv[n+1];
			n++;
		} else if (strcmp(argv[n], "-gtsmaxglobals") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtsmaxglobals requires an argument\n");
				usage();
				return 2;
			}
			max_globals = katoi(argv[n+1]);
			n++;

		} else if (strcmp(argv[n], "-gtspref") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtspref requires an argument\n");
				usage();
				return 2;
			}
			path_prefs[npath_prefs++] = argv[n+1];
			path_prefs[npath_prefs] = NULL;
			n++;

		} else if (strcmp(argv[n], "-gtsunpref") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtsunpref requires an argument\n");
				usage();
				return 2;
			}
			path_un_prefs[npath_un_prefs++] = argv[n+1];
			path_un_prefs[npath_un_prefs] = NULL;
			n++;

		} else if (strcmp(argv[n], "-gtssaveprefix") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtssaveprefix requires an argument\n");
				usage();
				return 2;
			}
			saveprefix = argv[n+1];
			n++;

		} else if (strcmp(argv[n], "-gtsfile") == 0) {

			struct stat sbuf;

			if (argc < n+2) {
				fprintf(stderr,	"-gtsfile requires an argument\n");
				usage();
				return 2;
			}

			gts_file = argv[n+1];
				
			if (stat(gts_file, &sbuf) == -1) {
				fprintf(stderr,
						"warning: %s does not exist, will be created\n",
						gts_file);
			} else {
				
				if ((zap_fp = fopen(gts_file, "r")) == NULL) {
					fprintf(stderr,	"you lose cannot open %s\n", gts_file);
					usage();
					return 2;
				}

				if (EhSymTableFpLoad(table, zap_fp) == -1) {
					fprintf(stderr,
							"error: failed reading symbols from gtsfile %s\n",
							argv[n+1]);
					usage();
					return 2;
				}
				
				fclose(zap_fp);
			}

			n++;

		} else if (strcmp(argv[n], "-gtszapsymbol") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtszapsymbol requires an argument\n");
				usage();
				return 2;
			}

			EhSymTableSetSymbolState(table, argv[n+1], EH_SYM_ZAPPED);
			n++;

		} else if (strcmp(argv[n], "-gtsnozapsymbol") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtsnozapsymbol requires an argument\n");
				usage();
				return 2;
			}

			EhSymTableSetSymbolState(table, argv[n+1], EH_SYM_DEFINED);
			n++;

		} else if (strcmp(argv[n], "-gtsname") == 0) {
			if (argc < n+2) {
				fprintf(stderr,	"-gtsname requires an argument\n");
				usage();
				return 2;
			}

			sym = EhSymTableFind(table, argv[n+1]);
			if (!sym)
				sym = EhSymNewRandomZap(argv[n+1]);
			n++;
			do_audit = 1;

		} else if (strcmp(argv[n], "-c") == 0) { /* do not link */
			in_link = 0;
			do_link = 0;
		} else if (strcmp(argv[n], "-S") == 0) { /* do not assem */
			do_assem = 0;
		} else if (strcmp(argv[n], "-o") == 0) { /* parse through */
			arg_buf[nargs++] = argv[n++];
			arg_buf[nargs++] = argv[n];
			arg_buf[nargs] = NULL;
		} else if (strcmp((suffix = suffix_name(argv[n])), ".cpp") == 0
				   ||
				   strcmp(suffix, ".c") == 0
				   ||
				   strcmp(suffix, ".s") == 0) {
			char pathname[MAXPATHLEN];

			make_relative_pathname(pathname, ".", rootdir);

			source = EhSourceNew(argv[n], arg_buf, pathname);

			rv = EhSourceCompile(source,
								 table,
								 verbosity,
								 TRUE, /* compile, .s files ignore anyway */
								 (do_audit + do_zap),
								 do_assem);
			if (rv == -1)
				return 1;

#if 0
			EhSourceAdjustPathname(source, rootdir);
#endif

		} else if (strcmp(suffix, ".o") == 0 || strcmp(suffix, ".a") == 0) {

			if (fileListFind(o_list, argv[n]) == NULL) {
				fileListAppend(&o_list, argv[n]);
			} else {
				fprintf(stderr,
						"%s repeated on command line - ignored\n",
						argv[n]);
			}
			arg_buf[nargs++] = argv[n];
			arg_buf[nargs] = NULL;

		} else if (strncmp(argv[n], "-L", 2) == 0) {
			EhDirMapAddDirectory(dmap, &argv[n][2]);
		} else if (strncmp(argv[n], "-l", 2) == 0) {
			char pathbuf[MAXPATHLEN];
			name = EhDirMapGetLibName(dmap, &argv[n][2], pathbuf);
			if (name != NULL) {
				if (fileListFind(o_list, name) == NULL) {
					fileListAppend(&o_list, name);
				} else {
					fprintf(stderr,
							"%s repeated on command line - ignored\n",
							name);
				}
			} else {
				fprintf(stderr, 
						"unable to resolve library reference %s - ignoring\n",
						argv[n]);
			}
			arg_buf[nargs++] = argv[n];
			arg_buf[nargs] = NULL;
		} else {
			arg_buf[nargs++] = argv[n];
			arg_buf[nargs] = NULL;
		}
	}

	/*
	 *    Analyse objects.
	 */
	if (o_list != NULL) {
		for (list = o_list; list != NULL; list = list->next) {

			if (eh_process_file(list->name, table, rootdir)) {
				fprintf(stderr, "oops we died around %s\n", list->name);
				return 1;
			}
		}
		
		/* look for unused objects */
		EhSymTableMap(table, object_nusers_mappee, 0);
	}

	if (do_summary) {
		print_summary(table);
	}

	if (do_dump) {
		print_dump(table);
	}

	if (!in_link && gts_file != NULL) {
		FILE* zap_fp;
		if ((zap_fp = fopen(gts_file, "w")) == NULL) {
			perror(0);
			usage();
			return 2;
		}

		EhSymTableFpDump(table, zap_fp);
		fclose(zap_fp);
		return 0;
	}

	/*
	 *    Now the fun really starts.
	 */
	if (do_recompile) {
		char** pp = NULL;
		char** up = NULL;
		
		if (npath_prefs > 0)
			pp = path_prefs;
		
		if (npath_un_prefs > 0)
			up = path_un_prefs;

		if (!do_collect)
			gts_file = NULL;
		
		rv = do_recompilation(table, gts_file, max_globals, pp, up, rootdir,
							  verbosity);
		if (rv == -1)
			return 1;
	}

	/*
	 *    Finally.
	 */
	if (do_link) {

		int status;

		arg_buf[nargs+1] = NULL;
		for (n = nargs; n > 0; n--)
			arg_buf[n] = arg_buf[n-1];
		arg_buf[0] = LD_COMMAND;
		
		status = do_command("link", arg_buf, verbosity);

		if (status == -1)
			return 3;
		else
			return status;
	}
	
	return 0;
}