Initial revision

10 files changed, 4736 insertions, 0 deletions

diff --git a/binutils/ar.c b/binutils/ar.c
new file mode 100644
index 0000000..9a8a528
--- /dev/null
+++ b/binutils/ar.c
@@ -0,0 +1,850 @@
+
+
+
+/* ar.c - Archive modify and extract. */
+/*
+   Bugs: should use getopt the way tar does (complete w/optional -) and
+   should have long options too. GNU ar used to check file against filesystem
+   in quick_update and replace operations (would check mtime). Doesn't warn
+   when name truncated. No way to specify pos_end. Error messages should be
+   more consistant.
+*/
+#include "sysdep.h"
+#include "bfd.h"
+#include "ar.h"
+#include <stdio.h>
+#include <sys/time.h>
+#include <errno.h>
+#define BUFSIZE 8192
+/* Not great to have these here.  Should they be exported or not? */
+PROTO(size_t, bfd_read, (void *ptr, size_t size, size_t nitems, bfd * abfd));
+PROTO(size_t, bfd_write, (void *ptr, size_t size, size_t nitems, bfd * abfd));
+/* PROTO (void, open_inarch, (char *archive_filename)); */
+#ifdef __STDC__
+static void     open_inarch(char *archive_filename);
+#else
+static void     open_inarch();
+#endif				/* __STDC__ */
+
+PROTO(void, map_over_members, (void (*function) (), char **files, int count));
+PROTO(void, print_contents, (bfd * member));
+PROTO(void, extract_file, (bfd * abfd));
+PROTO(void, delete_members, (char **files_to_delete));
+PROTO(void, do_quick_append, (char *archive_filename, char **files_to_append));
+PROTO(void, move_members, (char **files_to_move));
+PROTO(void, replace_members, (char **files_to_replace));
+PROTO(void, print_descr, (bfd * abfd));
+PROTO(void, ranlib_only, (char *archname));
+
+/** Globals and flags */
+
+char           *program_name = NULL;
+bfd             bogus_archive;
+bfd            *inarch;		/* The input arch we're manipulating */
+
+/* Nonzero means don't warn about creating the archive file if necessary.  */
+int             silent_create = 0;
+/* Nonzero means describe each action performed.  */
+int             verbose = 0;
+/* Nonzero means preserve dates of members when extracting them.  */
+int             preserve_dates = 0;
+/*
+   Nonzero means don't replace existing members whose dates are more recent
+   than the corresponding files.
+*/
+int             newer_only = 0;
+/* write a __.SYMDEF member into the modified archive.  */
+boolean         write_armap = false;
+/*
+   Nonzero means don't update __.SYMDEF unless command line explicitly
+   requested it
+*/
+int             ignore_symdef = 0;
+/*
+   Nonzero means it's the name of an existing member; position new or moved
+   files with respect to this one.
+*/
+char           *posname = NULL;
+/*
+   Sez how to use `posname': pos_before means position before that member.
+   pos_after means position after that member. pos_end means always at end.
+   pos_default means default appropriately. For the latter two, `posname'
+   should also be zero.
+*/
+enum pos {
+    pos_default, pos_before, pos_after, pos_end
+}               postype = pos_default;
+
+/*
+   The option parsing should be in its own function.  It will be when I have
+   getopt working.
+*/
+int
+main(argc, argv)
+    int             argc;
+    char          **argv;
+{
+    char           *arg_ptr;
+    char            c;
+    enum {
+	none = 0, delete, replace, print_table,
+	print_files, extract, move, quick_append
+    }               operation = none;
+    int             arg_index;
+    char          **files;
+    char           *inarch_filename;
+    char           *temp;
+    program_name = argv[0];
+
+
+    temp = strrchr(program_name, '/');
+    if (temp == (char *) NULL)
+	temp = program_name;	/* shouldn't happen, but... */
+    else
+	++temp;
+    if (!strcmp(temp, "ranlib")) {
+	if (argc < 2)
+	    fatal("Too few command arguments.");
+	ranlib_only(argv[1]);
+    }
+
+
+    if (argc < 3)
+	fatal("Too few command arguments.");
+
+    arg_ptr = argv[1];
+
+    if (*arg_ptr == '-')
+	++arg_ptr;		/* compatibility */
+
+    while (c = *arg_ptr++) {
+	switch (c) {
+	case 'd':
+	case 'm':
+	case 'p':
+	case 'q':
+	case 'r':
+	case 't':
+	case 'x':
+	    if (operation != none)
+		fatal("two different operation switches specified");
+	    switch (c) {
+	    case 'd':
+		operation = delete;
+		break;
+	    case 'm':
+		operation = move;
+		break;
+	    case 'p':
+		operation = print_files;
+		break;
+	    case 'q':
+		operation = quick_append;
+		break;
+	    case 'r':
+		operation = replace;
+		break;
+	    case 't':
+		operation = print_table;
+		break;
+	    case 'x':
+		operation = extract;
+		break;
+	    }
+	case 'l':
+	    break;
+	case 'c':
+	    silent_create = 1;
+	    break;
+	case 'o':
+	    preserve_dates = 1;
+	    break;
+	case 's':
+	    write_armap = true;
+	    break;
+	case 'u':
+	    newer_only = 1;
+	    break;
+	case 'v':
+	    verbose = 1;
+	    break;
+	case 'a':
+	    postype = pos_after;
+	    break;
+	case 'b':
+	    postype = pos_before;
+	    break;
+	case 'i':
+	    postype = pos_before;
+	    break;
+	default:
+	    fatal("invalid option %c", c);
+	}
+    }
+
+    if (operation == none && write_armap)
+	ranlib_only(argv[2]);
+
+    if (operation == none)
+	fatal("no operation specified");
+
+    if (newer_only && operation != replace)
+	fatal("'u' only meaningful with 'r' option.");
+
+    arg_index = 2;
+
+    if (postype != pos_default)
+	posname = argv[arg_index++];
+
+    inarch_filename = argv[arg_index++];
+
+    if (arg_index < argc) {
+	files = argv + arg_index;
+	while (arg_index < argc)
+	    if (!strcmp(argv[arg_index++], "__.SYMDEF")) {
+		ignore_symdef = 1;
+		break;
+	    }
+    }
+    else
+	files = NULL;
+
+    if (operation == quick_append) {
+	if (files != NULL)
+	    do_quick_append(inarch_filename, files);
+	exit(0);
+    }
+
+
+    open_inarch(inarch_filename);
+    /*
+       If we have no archive, and we've been asked to replace then create one
+    */
+
+    if (operation == replace &&
+	inarch == &bogus_archive) {
+	silent_create = 1;
+	do_quick_append(inarch_filename, 0);
+	open_inarch(inarch_filename);
+    }
+
+    switch (operation) {
+
+    case print_table:
+	map_over_members(print_descr, files, argc - 3);
+	break;
+
+    case print_files:
+	map_over_members(print_contents, files, argc - 3);
+	break;
+
+    case extract:
+	map_over_members(extract_file, files, argc - 3);
+	break;
+
+    case delete:
+	if (files != NULL)
+	    delete_members(files);
+	break;
+
+    case move:
+	if (files != NULL)
+	    move_members(files);
+	break;
+
+    case replace:
+	if (files != NULL || write_armap)
+	    replace_members(files);
+	break;
+
+	/* Shouldn't happen! */
+    default:
+	fprintf(stderr, "Sorry; this option not implemented.\n");
+    }
+
+    return (0);
+}				/* main() */
+
+static
+char *normalize(file)
+char *file;
+{
+    char *    filename = strrchr(file, '/');
+    if (filename != (char *)NULL) {
+	filename ++;
+    }
+    else {
+	filename = file;
+    }
+    return filename;
+}
+
+static void
+open_inarch(archive_filename)
+    char           *archive_filename;
+{
+    bfd           **last_one;
+    bfd            *next_one;
+    struct stat     sbuf;
+    bfd_error = no_error;
+    if (stat(archive_filename, &sbuf) != 0) {
+	if (errno != ENOENT)
+	    bfd_fatal(archive_filename);
+	if (!silent_create)
+	    fprintf(stderr,
+		    "%s: creating %s\n", program_name, archive_filename);
+
+	inarch = &bogus_archive;
+	inarch->filename = archive_filename;
+	inarch->has_armap = true;
+
+    }
+    else {
+	inarch = bfd_openr(archive_filename, NULL);
+	if (inarch == NULL) {
+    bloser:
+	    bfd_perror(archive_filename);
+	    exit(1);
+	}
+
+	if (bfd_check_format(inarch, bfd_archive) != true)
+	    fatal("File %s is not an archive.", archive_filename);
+	last_one = &(inarch->next);
+	/* Read all the contents right away, regardless. */
+	for (next_one = bfd_openr_next_archived_file(inarch, NULL);
+	     next_one;
+	     next_one = bfd_openr_next_archived_file(inarch, next_one)) {
+	    *last_one = next_one;
+	    last_one = &next_one->next;
+	}
+	*last_one = (bfd *) NULL;
+	if (bfd_error != no_more_archived_files)
+	    goto bloser;
+    }
+}
+
+
+
+/*
+   If count is 0, then function is called once on each entry. if nonzero,
+   count is the length of the files chain; function is called on each entry
+   whose name matches one in files
+*/
+void
+map_over_members(function, files, count)
+    void            (*function) ();
+    char          **files;
+    int             count;
+{
+    bfd            *head;
+
+
+
+
+    if (count == 0) {
+	for (head = inarch->next; head; head = head->next)
+	    function(head);
+	return;
+    }
+    /*
+       This may appear to be a baroque way of accomplishing what we want.
+       however we have to iterate over the filenames in order to notice where
+       a filename is requested but does not exist in the archive.  Ditto
+       mapping over each file each time -- we want to hack multiple
+       references.
+    */
+
+    for (; count > 0; files++, count--) {
+	boolean         found = false;
+	for (head = inarch->next; head; head = head->next)
+	    if ((head->filename != NULL) &&
+		(!strcmp(*files, head->filename))) {
+		found = true;
+		function(head);
+	    }
+	if (!found)
+	    fprintf(stderr, "No entry %s in archive.\n", *files);
+    }
+}
+
+
+/* Things which are interesting to map over all or some of the files: */
+
+void
+print_descr(abfd)
+    bfd            *abfd;
+{
+    print_arelt_descr(abfd, verbose);
+}
+
+void
+print_contents(abfd)
+    bfd            *abfd;
+{
+    int             ncopied = 0;
+    struct stat     buf;
+    long            size;
+    if (bfd_stat_arch_elt(abfd, &buf) != 0)
+	fatal("Internal stat error on %s", abfd->filename);
+
+    if (verbose)
+	printf("\n<member %s>\n\n", abfd->filename);
+
+    bfd_seek(abfd, 0, SEEK_SET);
+
+    size = buf.st_size;
+    while (ncopied < size) {
+	char            cbuf[BUFSIZE];
+	int             nread;
+	int             tocopy = size - ncopied;
+	if (tocopy > BUFSIZE)
+	    tocopy = BUFSIZE;
+
+	nread = bfd_read(cbuf, 1, tocopy, abfd);	/* oops -- broke
+							   abstraction!  */
+
+	if (nread != tocopy)
+	    fatal("file %s not a valid archive", abfd->my_archive->filename);
+	fwrite(cbuf, 1, nread, stdout);
+	ncopied += tocopy;
+    }
+}
+
+
+/*
+   Extract a member of the archive into its own file.
+
+We defer opening the new file until after we have read a BUFSIZ chunk of the
+   old one, since we know we have just read the archive header for the old
+   one.  Since most members are shorter than BUFSIZ, this means we will read
+   the old header, read the old data, write a new inode for the new file, and
+   write the new data, and be done. This 'optimization' is what comes from
+   sitting next to a bare disk and hearing it every time it seeks.  -- Gnu
+   Gilmore
+*/
+
+void
+extract_file(abfd)
+    bfd            *abfd;
+{
+    FILE           *ostream;
+    char            cbuf[BUFSIZE];
+    int             nread,
+                    tocopy;
+    int             ncopied = 0;
+    long            size;
+    struct stat     buf;
+    if (bfd_stat_arch_elt(abfd, &buf) != 0)
+	fatal("Internal stat error on %s", abfd->filename);
+    size = buf.st_size;
+
+    if (verbose)
+	printf("x - %s\n", abfd->filename);
+
+    bfd_seek(abfd, 0, SEEK_SET);
+
+    ostream = 0;
+    while (ncopied < size) {
+	tocopy = size - ncopied;
+	if (tocopy > BUFSIZE)
+	    tocopy = BUFSIZE;
+
+	nread = bfd_read(cbuf, 1, tocopy, abfd);
+	if (nread != tocopy)
+	    fatal("file %s not a valid archive", abfd->my_archive->filename);
+
+	/* See comment above; this saves disk arm motion */
+	if (!ostream) {
+	    /* Seems like an abstraction violation, eh?  Well it's OK! */
+	    ostream = fopen(abfd->filename, "w");
+	    if (!ostream) {
+		perror(abfd->filename);
+		exit(1);
+	    }
+	}
+	/* no need to byte-swap; the two formats are presumably compatible(!) */
+	fwrite(cbuf, 1, nread, ostream);
+	ncopied += tocopy;
+    }
+
+    fclose(ostream);
+    chmod(abfd->filename, buf.st_mode);
+
+    if (preserve_dates) {
+#ifdef USG
+	long            tb[2];
+	tb[0] = buf.st_mtime;
+	tb[1] = buf.st_mtime;
+	utime(abfd->filename, tb);	/* FIXME check result */
+#else
+	struct timeval  tv[2];
+	tv[0].tv_sec = buf.st_mtime;
+	tv[0].tv_usec = 0;
+	tv[1].tv_sec = buf.st_mtime;
+	tv[1].tv_usec = 0;
+	utimes(abfd->filename, tv);	/* FIXME check result */
+#endif
+    }
+}
+
+
+/* Just do it quickly; don't worry about dups, armap, or anything like that */
+
+/* This is ugly! XXX */
+
+PROTO(struct ar_hdr *, bfd_special_undocumented_glue, (char *filename));
+
+void
+do_quick_append(archive_filename, files_to_append)
+    char           *archive_filename;
+    char          **files_to_append;
+
+{
+    FILE           *ofile,
+                   *ifile;
+    char            buf[BUFSIZE];
+    long            tocopy,
+                    thistime;
+    bfd            *temp;
+    struct stat     sbuf;
+    boolean         newfile = false;
+    bfd_error = no_error;
+
+    if (stat(archive_filename, &sbuf) != 0) {
+	if (errno != ENOENT)
+	    bfd_fatal(archive_filename);
+	newfile = true;
+    }
+
+
+    ofile = fopen(archive_filename, "a+");
+    if (ofile == NULL) {
+	perror(program_name);
+	exit(1);
+    }
+
+    /* bletch */
+    temp = bfd_openr(archive_filename, NULL);
+    if (temp == NULL) {
+	bfd_perror(archive_filename);
+	exit(1);
+    }
+    if (newfile == false) {
+	if (bfd_check_format(temp, bfd_archive) != true)
+	    fatal("File %s is not an archive.", archive_filename);
+    }
+    else {
+	fwrite(ARMAG, 1, SARMAG, ofile);
+	if (!silent_create)
+	    fprintf(stderr, "%s: creating %s\n", program_name, archive_filename);
+    }
+
+    /* assume it's an achive, go straight to the end, sans $200 */
+    fseek(ofile, 0, 2);
+
+    for (; files_to_append && *files_to_append; ++files_to_append) {
+	struct ar_hdr  *hdr = bfd_special_undocumented_glue(*files_to_append);
+	if (hdr == NULL) {
+	    bfd_perror(*files_to_append);
+	    exit(1);
+	}
+
+	BFD_SEND(temp, _bfd_truncate_arname, (temp, *files_to_append, (char *) hdr));
+
+	ifile = fopen(*files_to_append, "r");
+	if (ifile == NULL)
+	    bfd_perror(program_name);
+
+	if (stat(*files_to_append, &sbuf) != 0)
+	    bfd_perror(*files_to_append);
+
+	tocopy = sbuf.st_size;
+
+	/* XXX should do error-checking! */
+	fwrite(hdr, 1, sizeof(struct ar_hdr), ofile);
+
+
+	while (tocopy > 0) {
+	    thistime = tocopy;
+	    if (thistime > BUFSIZE)
+		thistime = BUFSIZE;
+	    fread(buf, 1, thistime, ifile);
+	    fwrite(buf, 1, thistime, ofile);
+	    tocopy -= thistime;
+	}
+	fclose(ifile);
+	if ((sbuf.st_size % 2) == 1)
+	    putc('\n', ofile);
+    }
+    fclose(ofile);
+    bfd_close(temp);
+}
+
+
+void
+write_archive()
+{
+    bfd            *obfd;
+    char           *xmalloc();
+    int             namelen = strlen(inarch->filename);
+    char           *new_name = xmalloc(namelen + 6);
+    bfd            *contents_head = inarch->next;
+    if (inarch == &bogus_archive) {
+	/* How can this be ? */
+	return;
+    }
+    else {
+
+	strcpy(new_name, inarch->filename);
+	strcpy(new_name + namelen, ".art");
+	obfd = bfd_openw(new_name, bfd_get_target(inarch));
+
+	if (obfd == NULL)
+	    bfd_fatal(inarch->filename);
+
+	bfd_set_format(obfd, bfd_archive);
+	obfd->has_armap = write_armap;
+
+	if (bfd_set_archive_head(obfd, contents_head) != true)
+	    bfd_fatal(inarch->filename);
+
+	if (!bfd_close(obfd))
+	    bfd_fatal(inarch->filename);
+	if (rename(new_name, inarch->filename) != 0)
+	    bfd_fatal(inarch->filename);
+    }
+}
+
+
+
+/*
+   returns a pointer to the pointer to the entry which should be rplacd'd
+   into when altering.  default_pos should be how to interpret pos_default,
+   and should be a pos value.
+*/
+
+bfd **
+get_pos_bfd(contents, default_pos)
+    bfd           **contents;
+    enum pos        default_pos;
+{
+    bfd           **after_bfd;
+
+    enum pos        realpos = (postype == pos_default ? default_pos : postype);
+    switch (realpos) {
+
+    case pos_end:
+	after_bfd = contents;
+	while (*after_bfd) {
+	    after_bfd = &((*after_bfd)->next);
+	}
+
+	break;
+#if 0
+    case pos_after:
+	for (after_bfd = contents; after_bfd; after_bfd = after_bfd->next)
+	    if (!strcpy(after_bfd->filename, posname))
+		break;
+	break;
+    case pos_before:
+	for (after_bfd = contents; after_bfd; after_bfd = after_bfd->next)
+	    if (after_bfd->next && (!strcpy(after_bfd->next->filename, posname)))
+		break;
+#endif
+    }
+
+    return after_bfd;
+}
+
+
+void
+delete_members(files_to_delete)
+    char          **files_to_delete;
+{
+    bfd           **current_ptr_ptr;
+    boolean         found;
+    boolean         something_changed = false;
+    for (; *files_to_delete != NULL; ++files_to_delete) {
+	/*
+	   In a.out systems, the armap is optional.  It's also called
+	   __.SYMDEF.  So if the user asked to delete it, we should remember
+	   that fact. The name is NULL in COFF archives, so using this as a
+	   key is as good as anything I suppose
+	*/
+	if (!strcmp(*files_to_delete, "__.SYMDEF")) {
+	    inarch->has_armap = false;
+	    write_armap = false;
+	    continue;
+	}
+
+	found = false;
+	current_ptr_ptr = &(inarch->next);
+	while (*current_ptr_ptr) {
+	    if (strcmp(*files_to_delete, (*current_ptr_ptr)->filename) == 0) {
+		found = true;
+		something_changed = true;
+		if (verbose)
+		    printf("d - %s\n",
+			   *files_to_delete);
+		*current_ptr_ptr = ((*current_ptr_ptr)->next);
+		goto next_file;
+
+	    }
+	    else {
+		current_ptr_ptr = &((*current_ptr_ptr)->next);
+	    }
+	}
+
+	if (verbose && found == false) {
+	    printf("No member named `%s'\n", *files_to_delete);
+	}
+next_file:;
+
+    }
+
+    if (something_changed == true) {
+	write_archive();
+    }
+}
+
+
+/* Reposition existing members within an archive */
+
+void
+move_members(files_to_move)
+    char          **files_to_move;
+{
+    bfd           **after_bfd;	/* New entries go after this one */
+    bfd           **current_ptr_ptr;	/* cdr pointer into contents */
+
+
+
+
+    for (; *files_to_move; ++files_to_move) {
+	current_ptr_ptr = &(inarch->next);
+	while (*current_ptr_ptr) {
+	    bfd            *current_ptr = *current_ptr_ptr;
+	    if (strcmp(normalize(*files_to_move), current_ptr->filename) == 0) {
+		/*
+		   Move this file to the end of the list - first cut from
+		   where it is.
+		*/
+		*current_ptr_ptr = current_ptr->next;
+
+		/* Now glue to end */
+		after_bfd = get_pos_bfd(&inarch->next, pos_end);
+		*after_bfd = current_ptr;
+		current_ptr->next = (bfd *) NULL;
+
+		if (verbose)
+		    printf("m - %s\n", *files_to_move);
+
+		goto next_file;
+	    }
+	    current_ptr_ptr = &((*current_ptr_ptr)->next);
+	}
+	fprintf(stderr, "No entry %s in archive %s!\n",
+		*files_to_move, inarch->filename);
+	exit(1);
+next_file:;
+    }
+
+    write_archive();
+}
+
+
+/* Ought to default to replacing in place, but this is existing practice! */
+
+void
+replace_members(files_to_move)
+    char          **files_to_move;
+{
+    bfd           **after_bfd;	/* New entries go after this one */
+    bfd            *current;
+    bfd           **current_ptr;
+    bfd            *temp;
+    /*
+       If the first item in the archive is an __.SYMDEF then remove it
+    */
+    if (inarch->next &&
+	strcmp(inarch->next->filename, "__.SYMDEF") == 0) {
+	inarch->next = inarch->next->next;
+    }
+
+
+
+    while (files_to_move && *files_to_move) {
+	current_ptr = &inarch->next;
+	while (*current_ptr) {
+	    current = *current_ptr;
+	    
+	    if (!strcmp(normalize(*files_to_move), current->filename)) {
+		/* snip out this entry from the chain */
+		*current_ptr = current->next;
+		if (newer_only) {
+		    struct stat     fsbuf,
+		                    asbuf;
+		    if (stat(*files_to_move, &fsbuf) != 0) {
+			if (errno != ENOENT)
+			    bfd_fatal(*files_to_move);
+			goto next_file;
+		    }
+		    if (bfd_stat_arch_elt(current, &asbuf) != 0)
+			fatal("Internal stat error on %s", current->filename);
+
+		    if (fsbuf.st_mtime <= asbuf.st_mtime)
+			goto next_file;
+		}
+
+
+		after_bfd = get_pos_bfd(&inarch->next, pos_end);
+		temp = *after_bfd;
+		*after_bfd = bfd_openr(*files_to_move, NULL);
+		if (*after_bfd == (bfd *) NULL) {
+		    fprintf(stderr, "Can't open file %s\n", *files_to_move);
+		    exit(1);
+		}
+		(*after_bfd)->next = temp;
+
+		if (verbose) {
+		    printf("%c - %s\n", (postype == pos_after ? 'r' : 'a'),
+			   *files_to_move);
+		}
+		goto next_file;
+	    }
+	    current_ptr = &(current->next);
+	}
+
+	/* It isn't in there, so add to end */
+
+	after_bfd = get_pos_bfd(&inarch->next, pos_end);
+	temp = *after_bfd;
+	*after_bfd = bfd_openr(*files_to_move, NULL);
+	if (*after_bfd == (bfd *) NULL) {
+	    fprintf(stderr, "Can't open file %s\n", *files_to_move);
+	    exit(1);
+	}
+	if (verbose) {
+	    printf("c - %s\n", *files_to_move);
+	}
+
+	(*after_bfd)->next = temp;
+
+next_file:;
+
+	files_to_move++;
+    }
+
+
+    write_archive();
+}
+
+void
+ranlib_only(archname)
+    char           *archname;
+{
+    write_armap = true;
+    open_inarch(archname);
+    write_archive();
+    exit(0);
+}
diff --git a/binutils/bucomm.c b/binutils/bucomm.c
new file mode 100644
index 0000000..00f379f
--- /dev/null
+++ b/binutils/bucomm.c
@@ -0,0 +1,151 @@
+/*** bucomm.c -- Bin Utils COMmon code.
+
+     We might put this in a library someday so it could be dynamically
+     loaded, but for now it's not necessary */
+
+#include "sysdep.h"
+#include "bfd.h"
+#include <varargs.h>
+
+char *target = NULL;		/* default as late as possible */
+
+/* Yes, this is what atexit is for, but that isn't guaranteed yet.
+   And yes, I know this isn't as good, but it does what is needed just fine */
+void (*exit_handler) ();
+
+/** Memory hackery */
+
+PROTO (char *, malloc, (unsigned size));
+PROTO (char *, realloc, (char *ptr, unsigned size));
+
+
+/* Error reporting */
+
+char *program_name;
+
+void
+bfd_fatal (string)
+     char *string;
+{
+  char *errmsg =  bfd_errmsg (bfd_error);
+  
+  if (string)
+    fprintf (stderr, "%s: %s: %s\n", program_name, string, errmsg);
+  else
+    fprintf (stderr, "%s: %s\n", program_name, errmsg);
+
+  if (NULL != exit_handler) (*exit_handler) ();
+  exit (1);
+}
+
+#ifndef NO_STDARG
+void
+fatal (Format)
+     const char *Format;
+{
+  va_list args;
+	
+  va_start (args, Format);
+  vfprintf (stderr, Format, args);
+  va_end (args);
+  (void) putc ('\n', stderr);
+  if (NULL != exit_handler) (*exit_handler) ();
+  exit (1);
+}
+#else
+#ifndef NO_VARARGS
+void fatal (va_alist)
+     va_dcl
+{
+	char *Format;
+	va_list args;
+	
+	va_start (args);
+	Format = va_arg(args, char *);
+	vfprintf (stderr, Format, args);
+	va_end (args);
+	(void) putc ('\n', stderr);
+	if (NULL != exit_handler) (*exit_handler) ();
+	exit (1);
+} /* fatal() */
+#else
+/*VARARGS1 */
+fatal (Format, args)
+     char *Format;
+{
+  as_where ();
+  _doprnt (Format, &args, stderr); /* not terribly portable, but... */
+  (void) putc ('\n', stderr);
+  if (NULL != exit_handler) (*exit_handler) ();
+  exit (1);
+}
+#endif /* not NO_VARARGS */
+#endif /* not NO_STDARG */
+
+
+/** Display the archive header for an element as if it were an ls -l listing */
+
+/* Mode       User\tGroup\tSize\tDate               Name */
+
+void
+print_arelt_descr (abfd, verbose)
+     bfd *abfd;
+     boolean verbose;
+{
+  struct stat buf;
+  char modebuf[11];
+  char timebuf[40];
+  long when;
+  long current_time = time ((long *) 0);
+
+  if (verbose) {
+
+    if (bfd_stat_arch_elt (abfd, &buf) == 0) { /* if not, huh? */
+
+      mode_string (buf.st_mode, modebuf);
+      modebuf[10] = '\0';
+      fputs (modebuf, stdout);
+
+      when = buf.st_mtime;
+      strcpy (timebuf, ctime (&when));
+
+      /* This code comes from gnu ls.  */
+      if ((current_time - when > 6 * 30 * 24 * 60 * 60)
+	  || (current_time - when < 0)) {
+	/* The file is fairly old or in the future.
+	   POSIX says the cutoff is 6 months old;
+	   approximate this by 6*30 days.
+	   Show the year instead of the time of day.  */
+	strcpy (timebuf + 11, timebuf + 19);
+      }
+      timebuf[16] = 0;
+
+      printf (" %d\t%d\t%ld\t%s ", buf.st_uid, buf.st_gid, buf.st_size, timebuf);
+    }
+  }
+
+  puts (abfd->filename);
+}
+
+/* Like malloc but get fatal error if memory is exhausted.  */
+char *
+xmalloc (size)
+     unsigned size;
+{
+  register char *result = malloc (size);
+  if (result == NULL && size != NULL) fatal ("virtual memory exhausted");
+
+  return result;
+}
+
+/* Like realloc but get fatal error if memory is exhausted.  */
+char *
+xrealloc (ptr, size)
+     char *ptr;
+     unsigned size;
+{
+  register char *result = realloc (ptr, size);
+  if (result == 0 && size != 0) fatal ("virtual memory exhausted");
+
+  return result;
+}
diff --git a/binutils/filemode.c b/binutils/filemode.c
new file mode 100644
index 0000000..1bb5e64
--- /dev/null
+++ b/binutils/filemode.c
@@ -0,0 +1,193 @@
+/* filemode.c -- make a string describing file modes
+   Copyright (C) 1985, 1990 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 1, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+void mode_string ();
+static char ftypelet ();
+static void rwx ();
+static void setst ();
+
+/* filemodestring - fill in string STR with an ls-style ASCII
+   representation of the st_mode field of file stats block STATP.
+   10 characters are stored in STR; no terminating null is added.
+   The characters stored in STR are:
+
+   0	File type.  'd' for directory, 'c' for character
+	special, 'b' for block special, 'm' for multiplex,
+	'l' for symbolic link, 's' for socket, 'p' for fifo,
+	'-' for any other file type
+
+   1	'r' if the owner may read, '-' otherwise.
+
+   2	'w' if the owner may write, '-' otherwise.
+
+   3	'x' if the owner may execute, 's' if the file is
+	set-user-id, '-' otherwise.
+	'S' if the file is set-user-id, but the execute
+	bit isn't set.
+
+   4	'r' if group members may read, '-' otherwise.
+
+   5	'w' if group members may write, '-' otherwise.
+
+   6	'x' if group members may execute, 's' if the file is
+	set-group-id, '-' otherwise.
+	'S' if it is set-group-id but not executable.
+
+   7	'r' if any user may read, '-' otherwise.
+
+   8	'w' if any user may write, '-' otherwise.
+
+   9	'x' if any user may execute, 't' if the file is "sticky"
+	(will be retained in swap space after execution), '-'
+	otherwise.
+	'T' if the file is sticky but not executable. */
+
+void
+filemodestring (statp, str)
+     struct stat *statp;
+     char *str;
+{
+  mode_string (statp->st_mode, str);
+}
+
+/* Like filemodestring, but only the relevant part of the `struct stat'
+   is given as an argument. */
+
+void
+mode_string (mode, str)
+     unsigned short mode;
+     char *str;
+{
+  str[0] = ftypelet (mode);
+  rwx ((mode & 0700) << 0, &str[1]);
+  rwx ((mode & 0070) << 3, &str[4]);
+  rwx ((mode & 0007) << 6, &str[7]);
+  setst (mode, str);
+}
+
+/* Return a character indicating the type of file described by
+   file mode BITS:
+   'd' for directories
+   'b' for block special files
+   'c' for character special files
+   'm' for multiplexor files
+   'l' for symbolic links
+   's' for sockets
+   'p' for fifos
+   '-' for any other file type. */
+
+static char
+ftypelet (bits)
+     unsigned short bits;
+{
+  switch (bits & S_IFMT)
+    {
+    default:
+      return '-';
+    case S_IFDIR:
+      return 'd';
+#ifdef S_IFLNK
+    case S_IFLNK:
+      return 'l';
+#endif
+#ifdef S_IFCHR
+    case S_IFCHR:
+      return 'c';
+#endif
+#ifdef S_IFBLK
+    case S_IFBLK:
+      return 'b';
+#endif
+#ifdef S_IFMPC
+    case S_IFMPC:
+    case S_IFMPB:
+      return 'm';
+#endif
+#ifdef S_IFSOCK
+    case S_IFSOCK:
+      return 's';
+#endif
+#ifdef S_IFIFO
+#if S_IFIFO != S_IFSOCK
+    case S_IFIFO:
+      return 'p';
+#endif
+#endif
+#ifdef S_IFNWK			/* HP-UX */
+    case S_IFNWK:
+      return 'n';
+#endif
+    }
+}
+
+/* Look at read, write, and execute bits in BITS and set
+   flags in CHARS accordingly. */
+
+static void
+rwx (bits, chars)
+     unsigned short bits;
+     char *chars;
+{
+  chars[0] = (bits & S_IREAD) ? 'r' : '-';
+  chars[1] = (bits & S_IWRITE) ? 'w' : '-';
+  chars[2] = (bits & S_IEXEC) ? 'x' : '-';
+}
+
+/* Set the 's' and 't' flags in file attributes string CHARS,
+   according to the file mode BITS. */
+
+static void
+setst (bits, chars)
+     unsigned short bits;
+     char *chars;
+{
+#ifdef S_ISUID
+  if (bits & S_ISUID)
+    {
+      if (chars[3] != 'x')
+	/* Set-uid, but not executable by owner. */
+	chars[3] = 'S';
+      else
+	chars[3] = 's';
+    }
+#endif
+#ifdef S_ISGID
+  if (bits & S_ISGID)
+    {
+      if (chars[6] != 'x')
+	/* Set-gid, but not executable by group. */
+	chars[6] = 'S';
+      else
+	chars[6] = 's';
+    }
+#endif
+#ifdef S_ISVTX
+  if (bits & S_ISVTX)
+    {
+      if (chars[9] != 'x')
+	/* Sticky, but not executable by others. */
+	chars[9] = 'T';
+      else
+	chars[9] = 't';
+    }
+#endif
+}
+
+
diff --git a/binutils/i960-pinsn.c b/binutils/i960-pinsn.c
new file mode 100644
index 0000000..1c7b719
--- /dev/null
+++ b/binutils/i960-pinsn.c
@@ -0,0 +1,820 @@
+/* Disassemble i80960 instructions.
+ */
+
+/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+
+This file is part of BFD, the Binary File Diddler.
+
+BFD is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+BFD is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with BFD; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* $Id$ 
+   $Log
+*/
+#include <stdio.h>
+#include "sysdep.h"
+#include "bfd.h"
+
+extern char *xmalloc();
+extern int fputs();
+
+static char *reg_names[] = {
+/*  0 */	"pfp", "sp",  "rip", "r3",  "r4",  "r5",  "r6",  "r7", 
+/*  8 */	"r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
+/* 16 */	"g0",  "g1",  "g2",  "g3",  "g4",  "g5",  "g6",  "g7", 
+/* 24 */	"g8",  "g9",  "g10", "g11", "g12", "g13", "g14", "fp", 
+/* 32 */	"pc",  "ac",  "ip",  "tc",  "fp0", "fp1", "fp2", "fp3" 
+};
+
+
+static FILE *stream;		/* Output goes here */
+static void print_addr();
+static void ctrl();
+static void cobr();
+static void reg();
+static int mem();
+static void ea();
+static void dstop();
+static void regop();
+static void invalid();
+static int pinsn();
+static void put_abs();
+
+
+/* Print the i960 instruction at address 'memaddr' in debugged memory,
+ * on stream 's'.  Returns length of the instruction, in bytes.
+ */
+int
+print_insn_i960( memaddr, buffer, s )
+    bfd_vma memaddr;
+uint8e_type *buffer;
+    FILE *s;
+{
+    unsigned int word1, word2;
+
+    stream = s;
+    word1 =buffer [0] |( buffer[1]<< 8) | (buffer[2] << 16) | ( buffer[3] <<24);
+    word2 =buffer [4] |( buffer[5]<< 8) | (buffer[6] << 16) | ( buffer[7] <<24);
+    return pinsn( memaddr, word1, word2 );
+}
+
+#define IN_GDB
+
+/*****************************************************************************
+ *	All code below this point should be identical with that of
+ *	the disassembler in gdmp960.
+ *****************************************************************************/
+
+struct tabent {
+	char	*name;
+	char	numops;
+};
+
+static int
+pinsn( memaddr, word1, word2 )
+    unsigned long memaddr;
+    unsigned long word1, word2;
+{
+	int instr_len;
+
+	instr_len = 4;
+	put_abs( word1, word2 );
+
+	/* Divide instruction set into classes based on high 4 bits of opcode*/
+	switch ( (word1 >> 28) & 0xf ){
+	case 0x0:
+	case 0x1:
+		ctrl( memaddr, word1, word2 );
+		break;
+	case 0x2:
+	case 0x3:
+		cobr( memaddr, word1, word2 );
+		break;
+	case 0x5:
+	case 0x6:
+	case 0x7:
+		reg( word1 );
+		break;
+	case 0x8:
+	case 0x9:
+	case 0xa:
+	case 0xb:
+	case 0xc:
+		instr_len = mem( memaddr, word1, word2, 0 );
+		break;
+	default:
+		/* invalid instruction, print as data word */ 
+		invalid( word1 );
+		break;
+	}
+	return instr_len;
+}
+
+/****************************************/
+/* CTRL format				*/
+/****************************************/
+static void
+ctrl( memaddr, word1, word2 )
+    unsigned long memaddr;
+    unsigned long word1, word2;
+{
+	int i;
+	static struct tabent ctrl_tab[] = {
+		NULL,		0,	/* 0x00 */
+		NULL,		0,	/* 0x01 */
+		NULL,		0,	/* 0x02 */
+		NULL,		0,	/* 0x03 */
+		NULL,		0,	/* 0x04 */
+		NULL,		0,	/* 0x05 */
+		NULL,		0,	/* 0x06 */
+		NULL,		0,	/* 0x07 */
+		"b",		1,	/* 0x08 */
+		"call",		1,	/* 0x09 */
+		"ret",		0,	/* 0x0a */
+		"bal",		1,	/* 0x0b */
+		NULL,		0,	/* 0x0c */
+		NULL,		0,	/* 0x0d */
+		NULL,		0,	/* 0x0e */
+		NULL,		0,	/* 0x0f */
+		"bno",		1,	/* 0x10 */
+		"bg",		1,	/* 0x11 */
+		"be",		1,	/* 0x12 */
+		"bge",		1,	/* 0x13 */
+		"bl",		1,	/* 0x14 */
+		"bne",		1,	/* 0x15 */
+		"ble",		1,	/* 0x16 */
+		"bo",		1,	/* 0x17 */
+		"faultno",	0,	/* 0x18 */
+		"faultg",	0,	/* 0x19 */
+		"faulte",	0,	/* 0x1a */
+		"faultge",	0,	/* 0x1b */
+		"faultl",	0,	/* 0x1c */
+		"faultne",	0,	/* 0x1d */
+		"faultle",	0,	/* 0x1e */
+		"faulto",	0,	/* 0x1f */
+	};
+
+	i = (word1 >> 24) & 0xff;
+	if ( (ctrl_tab[i].name == NULL) || ((word1 & 1) != 0) ){
+		invalid( word1 );
+		return;
+	}
+
+	fputs( ctrl_tab[i].name, stream );
+	if ( word1 & 2 ){		/* Predicts branch not taken */
+		fputs( ".f", stream );
+	}
+
+	if ( ctrl_tab[i].numops == 1 ){
+		/* EXTRACT DISPLACEMENT AND CONVERT TO ADDRESS */
+		word1 &= 0x00ffffff;
+		if ( word1 & 0x00800000 ){		/* Sign bit is set */
+			word1 |= (-1 & ~0xffffff);	/* Sign extend */
+		}
+		putc( '\t', stream );
+		print_addr( word1 + memaddr );
+	}
+}
+
+/****************************************/
+/* COBR format				*/
+/****************************************/
+static void
+cobr( memaddr, word1, word2 )
+    unsigned long memaddr;
+    unsigned long word1, word2;
+{
+	int src1;
+	int src2;
+	int i;
+
+	static struct tabent cobr_tab[] = {
+		"testno",	1,	/* 0x20 */
+		"testg",	1,	/* 0x21 */
+		"teste",	1,	/* 0x22 */
+		"testge",	1,	/* 0x23 */
+		"testl",	1,	/* 0x24 */
+		"testne",	1,	/* 0x25 */
+		"testle",	1,	/* 0x26 */
+		"testo",	1,	/* 0x27 */
+		NULL,		0,	/* 0x28 */
+		NULL,		0,	/* 0x29 */
+		NULL,		0,	/* 0x2a */
+		NULL,		0,	/* 0x2b */
+		NULL,		0,	/* 0x2c */
+		NULL,		0,	/* 0x2d */
+		NULL,		0,	/* 0x2e */
+		NULL,		0,	/* 0x2f */
+		"bbc",		3,	/* 0x30 */
+		"cmpobg",	3,	/* 0x31 */
+		"cmpobe",	3,	/* 0x32 */
+		"cmpobge",	3,	/* 0x33 */
+		"cmpobl",	3,	/* 0x34 */
+		"cmpobne",	3,	/* 0x35 */
+		"cmpoble",	3,	/* 0x36 */
+		"bbs",		3,	/* 0x37 */
+		"cmpibno",	3,	/* 0x38 */
+		"cmpibg",	3,	/* 0x39 */
+		"cmpibe",	3,	/* 0x3a */
+		"cmpibge",	3,	/* 0x3b */
+		"cmpibl",	3,	/* 0x3c */
+		"cmpibne",	3,	/* 0x3d */
+		"cmpible",	3,	/* 0x3e */
+		"cmpibo",	3,	/* 0x3f */
+	};
+
+	i = ((word1 >> 24) & 0xff) - 0x20;
+	if ( cobr_tab[i].name == NULL ){
+		invalid( word1 );
+		return;
+	}
+
+	fputs( cobr_tab[i].name, stream );
+	if ( word1 & 2 ){		/* Predicts branch not taken */
+		fputs( ".f", stream );
+	}
+	putc( '\t', stream );
+
+	src1 = (word1 >> 19) & 0x1f;
+	src2 = (word1 >> 14) & 0x1f;
+
+	if ( word1 & 0x02000 ){		/* M1 is 1 */
+		fprintf( stream, "%d", src1 );
+	} else {			/* M1 is 0 */
+		fputs( reg_names[src1], stream );
+	}
+
+	if ( cobr_tab[i].numops > 1 ){
+		if ( word1 & 1 ){		/* S2 is 1 */
+			fprintf( stream, ",sf%d,", src2 );
+		} else {			/* S1 is 0 */
+			fprintf( stream, ",%s,", reg_names[src2] );
+		}
+
+		/* Extract displacement and convert to address
+		 */
+		word1 &= 0x00001ffc;
+		if ( word1 & 0x00001000 ){	/* Negative displacement */
+			word1 |= (-1 & ~0x1fff);	/* Sign extend */
+		}
+		print_addr( memaddr + word1 );
+	}
+}
+
+/****************************************/
+/* MEM format				*/
+/****************************************/
+static int				/* returns instruction length: 4 or 8 */
+mem( memaddr, word1, word2, noprint )
+    unsigned long memaddr;
+    unsigned long word1, word2;
+    int noprint;		/* If TRUE, return instruction length, but
+				 * don't output any text.
+				 */
+{
+	int i, j;
+	int len;
+	int mode;
+	int offset;
+	char *reg1, *reg2, *reg3;
+
+	/* This lookup table is too sparse to make it worth typing in, but not
+	 * so large as to make a sparse array necessary.  We allocate the
+	 * table at runtime, initialize all entries to empty, and copy the
+	 * real ones in from an initialization table.
+	 *
+	 * NOTE: In this table, the meaning of 'numops' is:
+	 *	 1: single operand
+	 *	 2: 2 operands, load instruction
+	 *	-2: 2 operands, store instruction
+	 */
+	static struct tabent *mem_tab = NULL;
+	static struct { int opcode; char *name; char numops; } mem_init[] = {
+#define MEM_MIN	0x80
+		0x80,	"ldob",	 2,
+		0x82,	"stob",	-2,
+		0x84,	"bx",	 1,
+		0x85,	"balx",	 2,
+		0x86,	"callx", 1,
+		0x88,	"ldos",	 2,
+		0x8a,	"stos",	-2,
+		0x8c,	"lda",	 2,
+		0x90,	"ld",	 2,
+		0x92,	"st",	-2,
+		0x98,	"ldl",	 2,
+		0x9a,	"stl",	-2,
+		0xa0,	"ldt",	 2,
+		0xa2,	"stt",	-2,
+		0xb0,	"ldq",	 2,
+		0xb2,	"stq",	-2,
+		0xc0,	"ldib",	 2,
+		0xc2,	"stib",	-2,
+		0xc8,	"ldis",	 2,
+		0xca,	"stis",	-2,
+#define MEM_MAX	0xca
+#define MEM_SIZ	((MEM_MAX-MEM_MIN+1) * sizeof(struct tabent))
+		0,	NULL,	0
+	};
+
+	if ( mem_tab == NULL ){
+		mem_tab = (struct tabent *) xmalloc( MEM_SIZ );
+		bzero( (void *) mem_tab, MEM_SIZ );
+		for ( i = 0; mem_init[i].opcode != 0; i++ ){
+			j = mem_init[i].opcode - MEM_MIN;
+			mem_tab[j].name = mem_init[i].name;
+			mem_tab[j].numops = mem_init[i].numops;
+		}
+	}
+
+	i = ((word1 >> 24) & 0xff) - MEM_MIN;
+	mode = (word1 >> 10) & 0xf;
+
+	if ( (mem_tab[i].name != NULL)		/* Valid instruction */
+	&&   ((mode == 5) || (mode >=12)) ){	/* With 32-bit displacement */
+		len = 8;
+	} else {
+		len = 4;
+	}
+
+	if ( noprint ){
+		return len;
+	}
+
+	if ( (mem_tab[i].name == NULL) || (mode == 6) ){
+		invalid( word1 );
+		return len;
+	}
+
+	fprintf( stream, "%s\t", mem_tab[i].name );
+
+	reg1 = reg_names[ (word1 >> 19) & 0x1f ];	/* MEMB only */
+	reg2 = reg_names[ (word1 >> 14) & 0x1f ];
+	reg3 = reg_names[ word1 & 0x1f ];		/* MEMB only */
+	offset = word1 & 0xfff;				/* MEMA only  */
+
+	switch ( mem_tab[i].numops ){
+
+	case 2: /* LOAD INSTRUCTION */
+		if ( mode & 4 ){			/* MEMB FORMAT */
+			ea( memaddr, mode, reg2, reg3, word1, word2 );
+			fprintf( stream, ",%s", reg1 );
+		} else {				/* MEMA FORMAT */
+			fprintf( stream, "0x%x", (unsigned) offset );
+			if (mode & 8) {
+				fprintf( stream, "(%s)", reg2 );
+			}
+			fprintf( stream, ",%s", reg1 );
+		}
+		break;
+
+	case -2: /* STORE INSTRUCTION */
+		if ( mode & 4 ){			/* MEMB FORMAT */
+			fprintf( stream, "%s,", reg1 );
+			ea( memaddr, mode, reg2, reg3, word1, word2 );
+		} else {				/* MEMA FORMAT */
+			fprintf( stream, "%s,0x%x", reg1, (unsigned) offset );
+			if (mode & 8) {
+				fprintf( stream, "(%s)", reg2 );
+			}
+		}
+		break;
+
+	case 1: /* BX/CALLX INSTRUCTION */
+		if ( mode & 4 ){			/* MEMB FORMAT */
+			ea( memaddr, mode, reg2, reg3, word1, word2 );
+		} else {				/* MEMA FORMAT */
+			fprintf( stream, "0x%x", (unsigned) offset );
+			if (mode & 8) {
+				fprintf( stream, "(%s)", reg2 );
+			}
+		}
+		break;
+	}
+
+	return len;
+}
+
+/****************************************/
+/* REG format				*/
+/****************************************/
+static void
+reg( word1 )
+    unsigned long word1;
+{
+	int i, j;
+	int opcode;
+	int fp;
+	int m1, m2, m3;
+	int s1, s2;
+	int src, src2, dst;
+	char *mnemp;
+
+	/* This lookup table is too sparse to make it worth typing in, but not
+	 * so large as to make a sparse array necessary.  We allocate the
+	 * table at runtime, initialize all entries to empty, and copy the
+	 * real ones in from an initialization table.
+	 *
+	 * NOTE: In this table, the meaning of 'numops' is:
+	 *	 1: single operand, which is NOT a destination.
+	 *	-1: single operand, which IS a destination.
+	 *	 2: 2 operands, the 2nd of which is NOT a destination.
+	 *	-2: 2 operands, the 2nd of which IS a destination.
+	 *	 3: 3 operands
+	 *
+	 *	If an opcode mnemonic begins with "F", it is a floating-point
+	 *	opcode (the "F" is not printed).
+	 */
+
+	static struct tabent *reg_tab = NULL;
+	static struct { int opcode; char *name; char numops; } reg_init[] = {
+#define REG_MIN	0x580
+		0x580,	"notbit",	3,
+		0x581,	"and",		3,
+		0x582,	"andnot",	3,
+		0x583,	"setbit",	3,
+		0x584,	"notand",	3,
+		0x586,	"xor",		3,
+		0x587,	"or",		3,
+		0x588,	"nor",		3,
+		0x589,	"xnor",		3,
+		0x58a,	"not",		-2,
+		0x58b,	"ornot",	3,
+		0x58c,	"clrbit",	3,
+		0x58d,	"notor",	3,
+		0x58e,	"nand",		3,
+		0x58f,	"alterbit",	3,
+		0x590, 	"addo",		3,
+		0x591, 	"addi",		3,
+		0x592, 	"subo",		3,
+		0x593, 	"subi",		3,
+		0x598, 	"shro",		3,
+		0x59a, 	"shrdi",	3,
+		0x59b, 	"shri",		3,
+		0x59c, 	"shlo",		3,
+		0x59d, 	"rotate",	3,
+		0x59e, 	"shli",		3,
+		0x5a0, 	"cmpo",		2,
+		0x5a1, 	"cmpi",		2,
+		0x5a2, 	"concmpo",	2,
+		0x5a3, 	"concmpi",	2,
+		0x5a4, 	"cmpinco",	3,
+		0x5a5, 	"cmpinci",	3,
+		0x5a6, 	"cmpdeco",	3,
+		0x5a7, 	"cmpdeci",	3,
+		0x5ac, 	"scanbyte",	2,
+		0x5ae, 	"chkbit",	2,
+		0x5b0, 	"addc",		3,
+		0x5b2, 	"subc",		3,
+		0x5cc,	"mov",		-2,
+		0x5d8,	"eshro",	3,
+		0x5dc,	"movl",		-2,
+		0x5ec,	"movt",		-2,
+		0x5fc,	"movq",		-2,
+		0x600,	"synmov",	2,
+		0x601,	"synmovl",	2,
+		0x602,	"synmovq",	2,
+		0x603,	"cmpstr",	3,
+		0x604,	"movqstr",	3,
+		0x605,	"movstr",	3,
+		0x610,	"atmod",	3,
+		0x612,	"atadd",	3,
+		0x613,	"inspacc",	-2,
+		0x614,	"ldphy",	-2,
+		0x615,	"synld",	-2,
+		0x617,	"fill",		3,
+		0x630,	"sdma",		3,
+		0x631,	"udma",		0,
+		0x640,	"spanbit",	-2,
+		0x641,	"scanbit",	-2,
+		0x642,	"daddc",	3,
+		0x643,	"dsubc",	3,
+		0x644,	"dmovt",	-2,
+		0x645,	"modac",	3,
+		0x646,	"condrec",	-2,
+		0x650,	"modify",	3,
+		0x651,	"extract",	3,
+		0x654,	"modtc",	3,
+		0x655,	"modpc",	3,
+		0x656,	"receive",	-2,
+		0x659,	"sysctl",	3,
+		0x660,	"calls",	1,
+		0x662,	"send",		3,
+		0x663,	"sendserv",	1,
+		0x664,	"resumprcs",	1,
+		0x665,	"schedprcs",	1,
+		0x666,	"saveprcs",	0,
+		0x668,	"condwait",	1,
+		0x669,	"wait",		1,
+		0x66a,	"signal",	1,
+		0x66b,	"mark",		0,
+		0x66c,	"fmark",	0,
+		0x66d,	"flushreg",	0,
+		0x66f,	"syncf",	0,
+		0x670,	"emul",		3,
+		0x671,	"ediv",		3,
+		0x673, 	"ldtime",	-1,
+		0x674,	"Fcvtir",	-2,
+		0x675,	"Fcvtilr",	-2,
+		0x676,	"Fscalerl",	3,
+		0x677,	"Fscaler",	3,
+		0x680,	"Fatanr",	3,
+		0x681,	"Flogepr",	3,
+		0x682,	"Flogr",	3,
+		0x683,	"Fremr",	3,
+		0x684,	"Fcmpor",	2,
+		0x685,	"Fcmpr",	2,
+		0x688,	"Fsqrtr",	-2,
+		0x689,	"Fexpr",	-2,
+		0x68a,	"Flogbnr",	-2,
+		0x68b,	"Froundr",	-2,
+		0x68c,	"Fsinr",	-2,
+		0x68d,	"Fcosr",	-2,
+		0x68e,	"Ftanr",	-2,
+		0x68f,	"Fclassr",	1,
+		0x690,	"Fatanrl",	3,
+		0x691,	"Flogeprl",	3,
+		0x692,	"Flogrl",	3,
+		0x693,	"Fremrl",	3,
+		0x694,	"Fcmporl",	2,
+		0x695,	"Fcmprl",	2,
+		0x698,	"Fsqrtrl",	-2,
+		0x699,	"Fexprl",	-2,
+		0x69a,	"Flogbnrl",	-2,
+		0x69b,	"Froundrl",	-2,
+		0x69c,	"Fsinrl",	-2,
+		0x69d,	"Fcosrl",	-2,
+		0x69e,	"Ftanrl",	-2,
+		0x69f,	"Fclassrl",	1,
+		0x6c0,	"Fcvtri",	-2,
+		0x6c1,	"Fcvtril",	-2,
+		0x6c2,	"Fcvtzri",	-2,
+		0x6c3,	"Fcvtzril",	-2,
+		0x6c9,	"Fmovr",	-2,
+		0x6d9,	"Fmovrl",	-2,
+		0x6e1, 	"Fmovre",	-2,
+		0x6e2, 	"Fcpysre",	3,
+		0x6e3, 	"Fcpyrsre",	3,
+		0x701,	"mulo",		3,
+		0x708,	"remo",		3,
+		0x70b,	"divo",		3,
+		0x741,	"muli",		3,
+		0x748,	"remi",		3,
+		0x749,	"modi",		3,
+		0x74b,	"divi",		3,
+		0x78b,	"Fdivr",	3,
+		0x78c,	"Fmulr",	3,
+		0x78d,	"Fsubr",	3,
+		0x78f,	"Faddr",	3,
+		0x79b,	"Fdivrl",	3,
+		0x79c,	"Fmulrl",	3,
+		0x79d,	"Fsubrl",	3,
+		0x79f,	"Faddrl",	3,
+#define REG_MAX	0x79f
+#define REG_SIZ	((REG_MAX-REG_MIN+1) * sizeof(struct tabent))
+		0,	NULL,	0
+	};
+
+	if ( reg_tab == NULL ){
+		reg_tab = (struct tabent *) xmalloc( REG_SIZ );
+		bzero( (void *) reg_tab, REG_SIZ );
+		for ( i = 0; reg_init[i].opcode != 0; i++ ){
+			j = reg_init[i].opcode - REG_MIN;
+			reg_tab[j].name = reg_init[i].name;
+			reg_tab[j].numops = reg_init[i].numops;
+		}
+	}
+
+	opcode = ((word1 >> 20) & 0xff0) | ((word1 >> 7) & 0xf);
+	i = opcode - REG_MIN;
+
+	if ( (opcode<REG_MIN) || (opcode>REG_MAX) || (reg_tab[i].name==NULL) ){
+		invalid( word1 );
+		return;
+	}
+
+	mnemp = reg_tab[i].name;
+	if ( *mnemp == 'F' ){
+		fp = 1;
+		mnemp++;
+	} else {
+		fp = 0;
+	}
+
+	fputs( mnemp, stream );
+
+	s1   = (word1 >> 5)  & 1;
+	s2   = (word1 >> 6)  & 1;
+	m1   = (word1 >> 11) & 1;
+	m2   = (word1 >> 12) & 1;
+	m3   = (word1 >> 13) & 1;
+	src  =  word1        & 0x1f;
+	src2 = (word1 >> 14) & 0x1f;
+	dst  = (word1 >> 19) & 0x1f;
+
+	if  ( reg_tab[i].numops != 0 ){
+		putc( '\t', stream );
+
+		switch ( reg_tab[i].numops ){
+		case 1:
+			regop( m1, s1, src, fp );
+			break;
+		case -1:
+			dstop( m3, dst, fp );
+			break;
+		case 2:
+			regop( m1, s1, src, fp );
+			putc( ',', stream );
+			regop( m2, s2, src2, fp );
+			break;
+		case -2:
+			regop( m1, s1, src, fp );
+			putc( ',', stream );
+			dstop( m3, dst, fp );
+			break;
+		case 3:
+			regop( m1, s1, src, fp );
+			putc( ',', stream );
+			regop( m2, s2, src2, fp );
+			putc( ',', stream );
+			dstop( m3, dst, fp );
+			break;
+		}
+	}
+}
+
+
+/*
+ * Print out effective address for memb instructions.
+ */
+static void
+ea( memaddr, mode, reg2, reg3, word1, word2 )
+    unsigned long memaddr;
+    int mode;
+    char *reg2, *reg3;
+int word1;
+    unsigned int word2;
+{
+	int scale;
+	static int scale_tab[] = { 1, 2, 4, 8, 16 };
+
+	scale = (word1 >> 7) & 0x07;
+	if ( (scale > 4) || ((word1 >> 5) & 0x03 != 0) ){
+		invalid( word1 );
+		return;
+	}
+	scale = scale_tab[scale];
+
+	switch (mode) {
+	case 4:	 					/* (reg) */
+		fprintf( stream, "(%s)", reg2 );
+		break;
+	case 5:						/* displ+8(ip) */
+		print_addr( word2+8+memaddr );
+		break;
+	case 7:						/* (reg)[index*scale] */
+		if (scale == 1) {
+			fprintf( stream, "(%s)[%s]", reg2, reg3 );
+		} else {
+			fprintf( stream, "(%s)[%s*%d]",reg2,reg3,scale);
+		}
+		break;
+	case 12:					/* displacement */
+		print_addr( word2 );
+		break;
+	case 13:					/* displ(reg) */
+		print_addr( word2 );
+		fprintf( stream, "(%s)", reg2 );
+		break;
+	case 14:					/* displ[index*scale] */
+		print_addr( word2 );
+		if (scale == 1) {
+			fprintf( stream, "[%s]", reg3 );
+		} else {
+			fprintf( stream, "[%s*%d]", reg3, scale );
+		}
+		break;
+	case 15:				/* displ(reg)[index*scale] */
+		print_addr( word2 );
+		if (scale == 1) {
+			fprintf( stream, "(%s)[%s]", reg2, reg3 );
+		} else {
+			fprintf( stream, "(%s)[%s*%d]",reg2,reg3,scale );
+		}
+		break;
+	default:
+		invalid( word1 );
+		return;
+	}
+}
+
+
+/************************************************/
+/* Register Instruction Operand  		*/
+/************************************************/
+static void
+regop( mode, spec, reg, fp )
+    int mode, spec, reg, fp;
+{
+	if ( fp ){				/* FLOATING POINT INSTRUCTION */
+		if ( mode == 1 ){			/* FP operand */
+			switch ( reg ){
+			case 0:  fputs( "fp0", stream );	break;
+			case 1:  fputs( "fp1", stream );	break;
+			case 2:  fputs( "fp2", stream );	break;
+			case 3:  fputs( "fp3", stream );	break;
+			case 16: fputs( "0f0.0", stream );	break;
+			case 22: fputs( "0f1.0", stream );	break;
+			default: putc( '?', stream );		break;
+			}
+		} else {				/* Non-FP register */
+			fputs( reg_names[reg], stream );
+		}
+	} else {				/* NOT FLOATING POINT */
+		if ( mode == 1 ){			/* Literal */
+			fprintf( stream, "%d", reg );
+		} else {				/* Register */
+			if ( spec == 0 ){
+				fputs( reg_names[reg], stream );
+			} else {
+				fprintf( stream, "sf%d", reg );
+			}
+		}
+	}
+}
+
+/************************************************/
+/* Register Instruction Destination Operand	*/
+/************************************************/
+static void
+dstop( mode, reg, fp )
+    int mode, reg, fp;
+{
+	/* 'dst' operand can't be a literal. On non-FP instructions,  register
+	 * mode is assumed and "m3" acts as if were "s3";  on FP-instructions,
+	 * sf registers are not allowed so m3 acts normally.
+	 */
+	 if ( fp ){
+		regop( mode, 0, reg, fp );
+	 } else {
+		regop( 0, mode, reg, fp );
+	 }
+}
+
+
+static void
+invalid( word1 )
+    int word1;
+{
+	fprintf( stream, ".word\t0x%08x", (unsigned) word1 );
+}	
+
+static void
+print_addr(a)
+int a;
+{
+	fprintf( stream, "0x%x", (unsigned) a );
+}
+
+static void
+put_abs( word1, word2 )
+    unsigned long word1, word2;
+{
+#ifdef IN_GDB
+	return;
+#else
+	int len;
+
+	switch ( (word1 >> 28) & 0xf ){
+	case 0x8:
+	case 0x9:
+	case 0xa:
+	case 0xb:
+	case 0xc:
+		/* MEM format instruction */
+		len = mem( 0, word1, word2, 1 );
+		break;
+	default:
+		len = 4;
+		break;
+	}
+
+	if ( len == 8 ){
+		fprintf( stream, "%08x %08x\t", word1, word2 );
+	} else {
+		fprintf( stream, "%08x         \t", word1 );
+	}
+;
+
+#endif
+}
diff --git a/binutils/m68k-pinsn.c b/binutils/m68k-pinsn.c
new file mode 100644
index 0000000..284f335
--- /dev/null
+++ b/binutils/m68k-pinsn.c
@@ -0,0 +1,806 @@
+/* Print m68k instructions for objdump
+   Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
+
+
+This file is part of the binutils.
+
+The binutils are free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+The binutils are distributed in the hope that they will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the binutils; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* $Id$
+   $Log$
+   Revision 1.1  1991/03/21 21:26:45  gumby
+   Initial revision
+
+ * Revision 1.1  1991/03/13  00:34:06  chrisb
+ * Initial revision
+ *
+ * Revision 1.4  1991/03/09  04:36:34  rich
+ *  Modified Files:
+ *  	sparc-pinsn.c ostrip.c objdump.c m68k-pinsn.c i960-pinsn.c
+ *  	binutils.h
+ *
+ * Pulled sysdep.h out of bfd.h.
+ *
+ * Revision 1.3  1991/03/08  21:54:45  rich
+ *  Modified Files:
+ *  	Makefile ar.c binutils.h bucomm.c copy.c cplus-dem.c getopt.c
+ *  	i960-pinsn.c m68k-pinsn.c nm.c objdump.c sparc-opcode.h
+ *  	sparc-pinsn.c strip.c
+ *
+ * Verifying Portland tree with steve's last changes.  Also, some partial
+ * porting.
+ *
+ * Revision 1.2  1991/03/08  07:46:24  sac
+ * Added -l option to disassembly - prints line numbers too.
+ *
+ * Revision 1.1  1991/02/22  16:48:02  sac
+ * Initial revision
+ *
+*/
+
+#include <stdio.h>
+#include "sysdep.h"
+#include "bfd.h"
+#include "m68k-opcode.h"
+
+extern int fputs();
+extern void print_address();
+
+/* 68k instructions are never longer than this many bytes.  */
+#define MAXLEN 22
+
+/* Number of elements in the opcode table.  */
+#define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
+
+extern char *reg_names[];
+char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
+		     "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
+
+char *reg_names[] = {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", "ps", "pc"};
+static unsigned char *print_insn_arg ();
+static unsigned char *print_indexed ();
+static void print_base ();
+static int fetch_arg ();
+
+#define NEXTBYTE(p)  (p += 2, ((char *)p)[-1])
+
+#define NEXTWORD(p)  \
+  (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
+
+#define NEXTLONG(p)  \
+  (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
+
+#define NEXTSINGLE(p) \
+  (p += 4, *((float *)(p - 4)))
+
+#define NEXTDOUBLE(p) \
+  (p += 8, *((double *)(p - 8)))
+
+#define NEXTEXTEND(p) \
+  (p += 12, 0.0)	/* Need a function to convert from extended to double
+			   precision... */
+
+#define NEXTPACKED(p) \
+  (p += 12, 0.0)	/* Need a function to convert from packed to double
+			   precision.   Actually, it's easier to print a
+			   packed number than a double anyway, so maybe
+			   there should be a special case to handle this... */
+
+/* Print the m68k instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+int
+print_insn_m68k(addr, buffer, stream)
+     bfd_vma addr;
+unsigned    char *buffer;
+     FILE *stream;
+{
+  register unsigned int i;
+  register unsigned char *p;
+  register char *d;
+  register unsigned int bestmask;
+  int best;
+
+
+
+  bestmask = 0;
+  best = -1;
+  for (i = 0; i < NOPCODES; i++)
+    {
+      register unsigned int opcode = m68k_opcodes[i].opcode;
+      register unsigned int match = m68k_opcodes[i].match;
+      if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
+	  && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
+	  && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
+	  && ((0xff & buffer[3] & match) == (0xff & opcode)))
+	{
+	  /* Don't use for printout the variants of divul and divsl
+	     that have the same register number in two places.
+	     The more general variants will match instead.  */
+	  for (d = m68k_opcodes[i].args; *d; d += 2)
+	    if (d[1] == 'D')
+	      break;
+
+	  /* Don't use for printout the variants of most floating
+	     point coprocessor instructions which use the same
+	     register number in two places, as above. */
+	  if (*d == 0)
+	    for (d = m68k_opcodes[i].args; *d; d += 2)
+	      if (d[1] == 't')
+		break;
+
+	  if (*d == 0 && match > bestmask)
+	    {
+	      best = i;
+	      bestmask = match;
+	    }
+	}
+    }
+
+  /* Handle undefined instructions.  */
+  if (best < 0)
+    {
+      fprintf (stream, "0%o", (unsigned) (buffer[0] << 8) + buffer[1]);
+      return 2;
+    }
+
+  fprintf (stream, "%s", m68k_opcodes[best].name);
+
+  /* Point at first word of argument data,
+     and at descriptor for first argument.  */
+  p = buffer + 2;
+  
+  /* Why do this this way? -MelloN */
+  for (d = m68k_opcodes[best].args; *d; d += 2)
+    {
+      if (d[0] == '#')
+	{
+	  if (d[1] == 'l' && p - buffer < 6)
+	    p = buffer + 6;
+	  else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
+	    p = buffer + 4;
+	}
+      if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
+	p = buffer + 4;
+      if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
+	p = buffer + 6;
+      if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
+	p = buffer + 4;
+    }
+
+  d = m68k_opcodes[best].args;
+
+  if (*d)
+    fputs (" ", stream);
+
+  while (*d)
+    {
+      p = print_insn_arg (d, buffer, p, addr + p - buffer, stream);
+      d += 2;
+      if (*d && *(d - 2) != 'I' && *d != 'k')
+	fputs (",", stream);
+    }
+  return p - buffer;
+}
+
+static unsigned char *
+print_insn_arg (d, buffer, p, addr, stream)
+     char *d;
+     unsigned char *buffer;
+     register unsigned char *p;
+ bfd_vma addr;		/* PC for this arg to be relative to */
+     FILE *stream;
+{
+  register int val;
+  register int place = d[1];
+  int regno;
+  register char *regname;
+  register unsigned char *p1;
+  register double flval;
+  int flt_p;
+
+  switch (*d)
+    {
+    case 'C':
+      fprintf (stream, "ccr");
+      break;
+
+    case 'S':
+      fprintf (stream, "sr");
+      break;
+
+    case 'U':
+      fprintf (stream, "usp");
+      break;
+
+    case 'J':
+      {
+	static struct { char *name; int value; } names[]
+	  = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
+	     {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
+	     {"msp", 0x803}, {"isp", 0x804}};
+
+	val = fetch_arg (buffer, place, 12);
+	for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
+	  if (names[regno].value == val)
+	    {
+	      fprintf (stream, names[regno].name);
+	      break;
+	    }
+	if (regno < 0)
+	  fprintf (stream, "%d", val);
+      }
+      break;
+
+    case 'Q':
+      val = fetch_arg (buffer, place, 3);
+      if (val == 0) val = 8;
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'M':
+      val = fetch_arg (buffer, place, 8);
+      if (val & 0x80)
+	val = val - 0x100;
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'T':
+      val = fetch_arg (buffer, place, 4);
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'D':
+      fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
+      break;
+
+    case 'A':
+      fprintf (stream, "%s",
+			reg_names[fetch_arg (buffer, place, 3) + 010]);
+      break;
+
+    case 'R':
+      fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
+      break;
+
+    case 'F':
+      fprintf (stream, "fp%d", fetch_arg (buffer, place, 3));
+      break;
+
+    case 'O':
+      val = fetch_arg (buffer, place, 6);
+      if (val & 0x20)
+	fprintf (stream, "%s", reg_names [val & 7]);
+      else
+	fprintf (stream, "%d", val);
+      break;
+
+    case '+':
+      fprintf (stream, "%s@+",
+			reg_names[fetch_arg (buffer, place, 3) + 8]);
+      break;
+
+    case '-':
+      fprintf (stream, "%s@-",
+	       reg_names[fetch_arg (buffer, place, 3) + 8]);
+      break;
+
+    case 'k':
+      if (place == 'k')
+	fprintf (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
+      else if (place == 'C')
+	{
+	  val = fetch_arg (buffer, place, 7);
+	  if ( val > 63 )		/* This is a signed constant. */
+	    val -= 128;
+	  fprintf (stream, "{#%d}", val);
+	}
+      else
+	fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      break;
+
+    case '#':
+    case '^':
+      p1 = buffer + (*d == '#' ? 2 : 4);
+      if (place == 's')
+	val = fetch_arg (buffer, place, 4);
+      else if (place == 'C')
+	val = fetch_arg (buffer, place, 7);
+      else if (place == '8')
+	val = fetch_arg (buffer, place, 3);
+      else if (place == '3')
+	val = fetch_arg (buffer, place, 8);
+      else if (place == 'b')
+	val = NEXTBYTE (p1);
+      else if (place == 'w')
+	val = NEXTWORD (p1);
+      else if (place == 'l')
+	val = NEXTLONG (p1);
+      else
+	fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      fprintf (stream, "#%d", val);
+      break;
+
+    case 'B':
+      if (place == 'b')
+	val = NEXTBYTE (p);
+      else if (place == 'w')
+	val = NEXTWORD (p);
+      else if (place == 'l')
+	val = NEXTLONG (p);
+      else if (place == 'g')
+	{
+	  val = ((char *)buffer)[1];
+	  if (val == 0)
+	    val = NEXTWORD (p);
+	  else if (val == -1)
+	    val = NEXTLONG (p);
+	}
+      else if (place == 'c')
+	{
+	  if (buffer[1] & 0x40)		/* If bit six is one, long offset */
+	    val = NEXTLONG (p);
+	  else
+	    val = NEXTWORD (p);
+	}
+      else
+	fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
+	       *d, place);
+      print_address (addr + val, stream);
+      break;
+
+    case 'd':
+      val = NEXTWORD (p);
+      fprintf (stream, "%s@(%d)",
+			reg_names[fetch_arg (buffer, place, 3)], val);
+      break;
+
+    case 's':
+      fprintf (stream, "%s",
+			fpcr_names[fetch_arg (buffer, place, 3)]);
+      break;
+
+    case 'I':
+      val = fetch_arg (buffer, 'd', 3);		  /* Get coprocessor ID... */
+      if (val != 1)				/* Unusual coprocessor ID? */
+	fprintf (stream, "(cpid=%d) ", val);
+      if (place == 'i')
+	p += 2;			     /* Skip coprocessor extended operands */
+      break;
+
+    case '*':
+    case '~':
+    case '%':
+    case ';':
+    case '@':
+    case '!':
+    case '$':
+    case '?':
+    case '/':
+    case '&':
+
+      if (place == 'd')
+	{
+	  val = fetch_arg (buffer, 'x', 6);
+	  val = ((val & 7) << 3) + ((val >> 3) & 7);
+	}
+      else
+	val = fetch_arg (buffer, 's', 6);
+
+      /* Get register number assuming address register.  */
+      regno = (val & 7) + 8;
+      regname = reg_names[regno];
+      switch (val >> 3)
+	{
+	case 0:
+	  fprintf (stream, "%s", reg_names[val]);
+	  break;
+
+	case 1:
+	  fprintf (stream, "%s", regname);
+	  break;
+
+	case 2:
+	  fprintf (stream, "%s@", regname);
+	  break;
+
+	case 3:
+	  fprintf (stream, "%s@+", regname);
+	  break;
+
+	case 4:
+	  fprintf (stream, "%s@-", regname);
+	  break;
+
+	case 5:
+	  val = NEXTWORD (p);
+	  fprintf (stream, "%s@(%d)", regname, val);
+	  break;
+
+	case 6:
+	  p = print_indexed (regno, p, addr, stream);
+	  break;
+
+	case 7:
+	  switch (val & 7)
+	    {
+	    case 0:
+	      val = NEXTWORD (p);
+	      fprintf (stream, "@#");
+	      print_address (val, stream);
+	      break;
+
+	    case 1:
+	      val = NEXTLONG (p);
+	      fprintf (stream, "@#");
+	      print_address (val, stream);
+	      break;
+
+	    case 2:
+	      val = NEXTWORD (p);
+	      print_address (addr + val, stream);
+	      break;
+
+	    case 3:
+	      p = print_indexed (-1, p, addr, stream);
+	      break;
+
+	    case 4:
+	      flt_p = 1;	/* Assume it's a float... */
+	      switch( place )
+	      {
+		case 'b':
+		  val = NEXTBYTE (p);
+		  flt_p = 0;
+		  break;
+
+		case 'w':
+		  val = NEXTWORD (p);
+		  flt_p = 0;
+		  break;
+
+		case 'l':
+		  val = NEXTLONG (p);
+		  flt_p = 0;
+		  break;
+
+		case 'f':
+		  flval = NEXTSINGLE(p);
+		  break;
+
+		case 'F':
+		  flval = NEXTDOUBLE(p);
+		  break;
+
+		case 'x':
+		  flval = NEXTEXTEND(p);
+		  break;
+
+		case 'p':
+		  flval = NEXTPACKED(p);
+		  break;
+
+		default:
+		  fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
+		       *d, place);
+	      }
+	      if ( flt_p )	/* Print a float? */
+		fprintf (stream, "#%g", flval);
+	      else
+		fprintf (stream, "#%d", val);
+	      break;
+
+	    default:
+	      fprintf (stream, "<invalid address mode 0%o>", (unsigned) val);
+	    }
+	}
+      break;
+
+    case 'L':
+    case 'l':
+	if (place == 'w')
+	  {
+	    char doneany;
+	    p1 = buffer + 2;
+	    val = NEXTWORD (p1);
+	    /* Move the pointer ahead if this point is farther ahead
+	       than the last.  */
+	    p = p1 > p ? p1 : p;
+	    if (val == 0)
+	      {
+		fputs ("#0", stream);
+		break;
+	      }
+	    if (*d == 'l')
+	      {
+		register int newval = 0;
+		for (regno = 0; regno < 16; ++regno)
+		  if (val & (0x8000 >> regno))
+		    newval |= 1 << regno;
+		val = newval;
+	      }
+	    val &= 0xffff;
+	    doneany = 0;
+	    for (regno = 0; regno < 16; ++regno)
+	      if (val & (1 << regno))
+		{
+		  int first_regno;
+		  if (doneany)
+		    fputs ("/", stream);
+		  doneany = 1;
+		  fprintf (stream, "%s", reg_names[regno]);
+		  first_regno = regno;
+		  while (val & (1 << (regno + 1)))
+		    ++regno;
+		  if (regno > first_regno)
+		    fprintf (stream, "-%s", reg_names[regno]);
+		}
+	  }
+	else if (place == '3')
+	  {
+	    /* `fmovem' insn.  */
+	    char doneany;
+	    val = fetch_arg (buffer, place, 8);
+	    if (val == 0)
+	      {
+		fputs ("#0", stream);
+		break;
+	      }
+	    if (*d == 'l')
+	      {
+		register int newval = 0;
+		for (regno = 0; regno < 8; ++regno)
+		  if (val & (0x80 >> regno))
+		    newval |= 1 << regno;
+		val = newval;
+	      }
+	    val &= 0xff;
+	    doneany = 0;
+	    for (regno = 0; regno < 8; ++regno)
+	      if (val & (1 << regno))
+		{
+		  int first_regno;
+		  if (doneany)
+		    fputs ("/", stream);
+		  doneany = 1;
+		  fprintf (stream, "fp%d", regno);
+		  first_regno = regno;
+		  while (val & (1 << (regno + 1)))
+		    ++regno;
+		  if (regno > first_regno)
+		    fprintf (stream, "-fp%d", regno);
+		}
+	  }
+	else
+	  abort ();
+      break;
+
+    default:
+      fprintf(stderr, "Invalid arg format in opcode table: \"%c\".", *d);
+    }
+
+  return (unsigned char *) p;
+}
+
+/* Fetch BITS bits from a position in the instruction specified by CODE.
+   CODE is a "place to put an argument", or 'x' for a destination
+   that is a general address (mode and register).
+   BUFFER contains the instruction.  */
+
+static int
+fetch_arg (buffer, code, bits)
+     unsigned char *buffer;
+     char code;
+     int bits;
+{
+  register int val;
+  switch (code)
+    {
+    case 's':
+      val = buffer[1];
+      break;
+
+    case 'd':			/* Destination, for register or quick.  */
+      val = (buffer[0] << 8) + buffer[1];
+      val >>= 9;
+      break;
+
+    case 'x':			/* Destination, for general arg */
+      val = (buffer[0] << 8) + buffer[1];
+      val >>= 6;
+      break;
+
+    case 'k':
+      val = (buffer[3] >> 4);
+      break;
+
+    case 'C':
+      val = buffer[3];
+      break;
+
+    case '1':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 12;
+      break;
+
+    case '2':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 6;
+      break;
+
+    case '3':
+    case 'j':
+      val = (buffer[2] << 8) + buffer[3];
+      break;
+
+    case '4':
+      val = (buffer[4] << 8) + buffer[5];
+      val >>= 12;
+      break;
+
+    case '5':
+      val = (buffer[4] << 8) + buffer[5];
+      val >>= 6;
+      break;
+
+    case '6':
+      val = (buffer[4] << 8) + buffer[5];
+      break;
+
+    case '7':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 7;
+      break;
+      
+    case '8':
+      val = (buffer[2] << 8) + buffer[3];
+      val >>= 10;
+      break;
+
+    default:
+      abort ();
+    }
+
+  switch (bits)
+    {
+    case 3:
+      return val & 7;
+    case 4:
+      return val & 017;
+    case 5:
+      return val & 037;
+    case 6:
+      return val & 077;
+    case 7:
+      return val & 0177;
+    case 8:
+      return val & 0377;
+    case 12:
+      return val & 07777;
+    default:
+      abort ();
+      return(0);
+    }
+} /* fetch_arg() */
+
+/* Print an indexed argument.  The base register is BASEREG (-1 for pc).
+   P points to extension word, in buffer.
+   ADDR is the nominal core address of that extension word.  */
+
+static unsigned char *
+print_indexed (basereg, p, addr, stream)
+     int basereg;
+     unsigned char *p;
+     FILE *stream;
+bfd_vma addr;
+{
+  register int word;
+  static char *scales[] = {"", "*2", "*4", "*8"};
+  register int base_disp;
+  register int outer_disp;
+  char buf[40];
+
+  word = NEXTWORD (p);
+
+  /* Generate the text for the index register.
+     Where this will be output is not yet determined.  */
+  sprintf (buf, "[%s.%c%s]",
+	   reg_names[(word >> 12) & 0xf],
+	   (word & 0x800) ? 'l' : 'w',
+	   scales[(word >> 9) & 3]);
+
+  /* Handle the 68000 style of indexing.  */
+
+  if ((word & 0x100) == 0)
+    {
+      print_base (basereg,
+		  ((word & 0x80) ? word | 0xff00 : word & 0xff)
+		  + ((basereg == -1) ? addr : 0),
+		  stream);
+      fputs (buf, stream);
+      return p;
+    }
+
+  /* Handle the generalized kind.  */
+  /* First, compute the displacement to add to the base register.  */
+
+  if (word & 0200)
+    basereg = -2;
+  if (word & 0100)
+    buf[0] = 0;
+  base_disp = 0;
+  switch ((word >> 4) & 3)
+    {
+    case 2:
+      base_disp = NEXTWORD (p);
+      break;
+    case 3:
+      base_disp = NEXTLONG (p);
+    }
+  if (basereg == -1)
+    base_disp += addr;
+
+  /* Handle single-level case (not indirect) */
+
+  if ((word & 7) == 0)
+    {
+      print_base (basereg, base_disp, stream);
+      fputs (buf, stream);
+      return p;
+    }
+
+  /* Two level.  Compute displacement to add after indirection.  */
+
+  outer_disp = 0;
+  switch (word & 3)
+    {
+    case 2:
+      outer_disp = NEXTWORD (p);
+      break;
+    case 3:
+      outer_disp = NEXTLONG (p);
+    }
+
+  fprintf (stream, "%d(", outer_disp);
+  print_base (basereg, base_disp, stream);
+
+  /* If postindexed, print the closeparen before the index.  */
+  if (word & 4)
+    fprintf (stream, ")%s", buf);
+  /* If preindexed, print the closeparen after the index.  */
+  else
+    fprintf (stream, "%s)", buf);
+
+  return p;
+}
+
+/* Print a base register REGNO and displacement DISP, on STREAM.
+   REGNO = -1 for pc, -2 for none (suppressed).  */
+
+static void
+print_base (regno, disp, stream)
+     int regno;
+     int disp;
+     FILE *stream;
+{
+  if (regno == -2)
+    fprintf (stream, "%d", disp);
+  else if (regno == -1)
+    fprintf (stream, "0x%x", (unsigned) disp);
+  else
+    fprintf (stream, "%d(%s)", disp, reg_names[regno]);
+}
diff --git a/binutils/nm.c b/binutils/nm.c
new file mode 100644
index 0000000..ac490f7
--- /dev/null
+++ b/binutils/nm.c
@@ -0,0 +1,387 @@
+/*** nm.c -- Describe symbol table of a rel file. */
+#include "sysdep.h"
+#include "bfd.h"
+#include "getopt.h"
+#include "stab.gnu.h"
+#include <ranlib.h>
+
+
+
+PROTO(static boolean, display_file, (char *filename));
+PROTO(static boolean, do_one_rel_file, (bfd *file));
+PROTO(static unsigned int, filter_symbols, (bfd *file, asymbol **syms,
+					 unsigned long symcount));
+
+PROTO(static void, print_symbols, (bfd *file, asymbol **syms,
+				     unsigned long symcount));
+extern PROTO(int, (*sorters[2][2]), (char *x, char *y));
+PROTO(static void, print_symdef_entry, (bfd * abfd));
+
+/* Command options.  */
+
+int external_only = 0;	/* print external symbols only */
+int file_on_each_line = 0; /* print file name on each line */
+int no_sort = 0;	/* don't sort; print syms in order found */
+int print_debug_syms = 0; /* print debugger-only symbols too */
+int print_armap = 0;	/* describe __.SYMDEF data in archive files.  */
+int reverse_sort = 0;	/* sort in downward(alpha or numeric) order */
+int sort_numerically = 0; /* sort in numeric rather than alpha order */
+int undefined_only = 0;	/* print undefined symbols only */
+
+boolean print_each_filename = false; /* Ick.  Used in archives. */
+
+/* IMPORT */
+extern char *program_name;
+extern char *program_version;
+extern char *target;
+
+struct option long_options[] = {
+	{"debug-syms",	    0, &print_debug_syms,  1},
+	{"extern-only",	    0, &external_only,     1},
+	{"no-sort",	    0, &no_sort,	   1},
+	{"numeric-sort",    0, &sort_numerically,  1},
+	{"print-armap",	    0, &print_armap,       1},
+	{"print-file-name", 0, &file_on_each_line, 1},
+	{"reverse-sort",    0, &reverse_sort,      1},
+	{"target", 	    2, NULL,	           NULL},
+	{"undefined-only",  0, &undefined_only,    1},
+	{0, 0, 0, 0}
+};
+
+/* Some error-reporting functions */
+
+void
+usage ()
+{
+  fprintf(stderr, "nm %s\nUsage: %s [-agnoprsu] filename...\n",
+	  program_version, program_name);
+  exit(0);
+}
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c; /* sez which option char */
+  int ind = 0; /* used by getopt and ignored by us */
+  extern int optind; /* steps thru options */
+	
+  program_name = *argv;
+	
+  while ((c = getopt_long(argc, argv, "agnoprsu", long_options, &ind)) != EOF) {
+    switch (c) {
+    case 'a': print_debug_syms = 1; break;
+    case 'g': external_only = 1; break;
+    case 'n': sort_numerically = 1; break;
+    case 'o': file_on_each_line = 1; break;
+    case 'p': no_sort = 1; break;
+    case 'r': reverse_sort = 1; break;
+    case 's': print_armap = 1; break;
+    case 'u': undefined_only = 1; break;
+			
+    case  0:
+      if (!strcmp("target",(long_options[option_index]).name)) {
+	target = optarg;
+      }
+			
+      break; /* we've been given a long option */
+			
+    default:
+      usage ();
+    }
+  }
+	
+  /* Strangely, for the shell you should return only a nonzero value
+     on sucess -- the inverse of the C sense. */
+  
+  /* OK, all options now parsed.  If no filename specified, do a.out. */
+  if (optind == argc) return !display_file ("a.out");
+  
+  /* We were given several filenames to do: */
+  while (optind < argc)
+    if (!display_file (argv[optind++])) return 1;
+
+  return 0;
+}
+
+/** Display a file's stats */
+
+/* goto here is marginally cleaner than the nested if syntax */
+
+static boolean
+display_file (filename)
+     char *filename;
+{
+  boolean retval = false;
+  bfd *file;
+  bfd *arfile = NULL;
+	
+  file = bfd_openr(filename, target);
+  if (file == NULL) {
+    bfd_fatal (filename);
+  }
+
+  if (bfd_check_format(file, bfd_object)) {
+    retval = do_one_rel_file (file);
+    goto closer;
+  }
+
+  if (!bfd_check_format (file, bfd_archive)) {
+    fprintf (stderr, "%s:  %s: unknown format.\n", program_name, filename);
+    retval = false;
+    goto closer;
+  }
+
+  printf("In archive %s:\n", filename);
+  if (print_armap) print_symdef_entry (file);
+  for (;;) {
+    arfile = bfd_openr_next_archived_file (file, arfile);
+
+    if (arfile == NULL) {
+      if (bfd_error != no_more_archived_files)
+	bfd_fatal (filename);
+      goto closer;
+    }
+			
+    if (!bfd_check_format(arfile, bfd_object))
+      printf("%s: not an object file\n", arfile->filename);
+    else {
+      printf ("\n%s:\n", arfile->filename);
+      if (!do_one_rel_file (arfile)) return false;
+    }
+  }
+
+ closer:
+  if (bfd_close(file) == false)
+    bfd_fatal (filename);
+
+  return retval;
+}
+
+
+static boolean
+do_one_rel_file (abfd)
+     bfd *abfd;
+{
+  unsigned int storage;
+  asymbol **syms;
+  unsigned int symcount = 0;
+
+  if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) {
+    (void) printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
+    return true;
+  }
+
+      
+  storage = get_symtab_upper_bound (abfd);
+  if (storage == 0) {
+  nosymz:
+    fprintf (stderr, "%s: Symflags set but there are none?\n",
+	     bfd_get_filename (abfd));
+    exit (1);
+  }
+
+  syms = (asymbol **) xmalloc (storage);
+
+  symcount = bfd_canonicalize_symtab (abfd, syms);
+  if (symcount == 0) goto nosymz;
+
+  /* Discard the symbols we don't want to print.
+     It's OK to do this in place; we'll free the storage anyway
+     (after printing) */
+
+  symcount = filter_symbols (abfd, syms, symcount);
+	
+  if (!no_sort) 
+    qsort((char *) syms, symcount, sizeof (asymbol *),
+	  sorters[sort_numerically][reverse_sort]);
+
+  if (print_each_filename && !file_on_each_line)
+    printf("\n%s:\n", bfd_get_filename(abfd));
+	
+  print_symbols (abfd, syms, symcount);
+  free (syms);
+  return true;
+}
+
+/* Symbol-sorting predicates */
+#define valueof(x)  ((x)->section ? (x)->section->vma + (x)->value : (x)->value)
+int
+numeric_forward (x, y)
+     char *x;
+     char *y;
+{
+
+  return (valueof(*(asymbol **)x) - valueof(*(asymbol **) y));;
+}
+
+int
+numeric_reverse (x, y)
+     char *x;
+     char *y;
+{
+  return (valueof(*(asymbol **)y) - valueof(*(asymbol **) x));
+
+}
+
+int
+non_numeric_forward (x, y)
+     char *x;
+     char *y;
+{
+  char *xn = (*(asymbol **) x)->name;
+  char *yn = (*(asymbol **) y)->name;
+
+  return ((xn == NULL) ? ((yn == NULL) ? 0 : -1) :
+	  ((yn == NULL) ? 1 : strcmp (xn, yn)));
+}
+
+int
+non_numeric_reverse (x, y)
+     char *x;
+     char *y;
+{
+  return -(non_numeric_forward (x, y));
+}
+
+int (*sorters[2][2])() = {
+	{non_numeric_forward, non_numeric_reverse},
+	{numeric_forward, numeric_reverse},
+};
+
+
+/* Choose which symbol entries to print;
+   compact them downward to get rid of the rest.
+   Return the number of symbols to be printed.  */
+static unsigned int
+filter_symbols (abfd, syms, symcount)
+     bfd *abfd;
+     asymbol **syms;
+     unsigned long symcount;
+{
+  asymbol **from, **to;
+  unsigned int dst_count = 0;
+  unsigned int src_count;
+  for (from = to = syms, src_count = 0; src_count <symcount; src_count++) {
+    int keep = 0;
+    flagword flags = (from[src_count])->flags;
+
+    if (undefined_only) {
+      keep = (flags & BSF_UNDEFINED);
+    } else if (external_only) {
+      keep = ((flags & BSF_GLOBAL) || (flags & BSF_UNDEFINED) ||
+	      (flags & BSF_FORT_COMM));
+    } else {
+      keep = 1;
+    }
+		
+    if (!print_debug_syms && ((flags & BSF_DEBUGGING) != 0)) {
+      keep = 0;
+    }
+
+    if (keep) {
+      to[dst_count++] = from[src_count];
+    }
+  }
+	
+  return dst_count;
+}
+
+
+/* Return a lower-case character corresponding to the symbol class of sym */
+char
+decode_symclass (sym)
+     asymbol *sym;
+{
+  flagword flags = sym->flags;
+  
+  if ((sym->value == 0) && (sym->section != NULL))
+    /* Huh?  All section names don't begin with "." */
+    return (sym->section->name)[1];
+
+  if (flags & BSF_FORT_COMM) return 'C';
+  if (flags & BSF_UNDEFINED) return 'U';
+  if (flags & BSF_ABSOLUTE)  return 'a';
+
+ 
+   if ( (flags & BSF_GLOBAL) || (flags & BSF_LOCAL) ){
+     if ( !strcmp(sym->section->name, ".text") ){
+       return 't';
+     } else if ( !strcmp(sym->section->name, ".data") ){
+       return 'd';
+     } else if ( !strcmp(sym->section->name, ".bss") ){
+       return 'b';
+     } else {
+       return 'o';
+     }
+    }
+
+  /* We don't have to handle these cases just yet, but we will soon:
+     N_SETV: 'v'; 
+     N_SETA: 'l'; 
+     N_SETT: 'x';
+     N_SETD: 'z';
+     N_SETB: 's';
+     N_INDR: 'i';
+     */
+ 
+  return '?';
+}
+
+static void
+print_symbols (abfd, syms, symcount)
+     bfd *abfd;
+     asymbol **syms;
+     unsigned long symcount;
+{
+  asymbol **sym = syms, **end = syms + symcount;
+  char class;
+
+  for (; sym < end; ++sym) {
+    if (file_on_each_line) printf("%s:", bfd_get_filename(abfd));
+
+    if (undefined_only) {
+      if ((*sym)->flags & BSF_UNDEFINED)
+	puts ((*sym)->name);
+    }
+    else {
+      asymbol *p = *sym;
+      if (p) {
+      class = decode_symclass (p);
+
+      if (p->flags & BSF_GLOBAL)
+	class = toupper (class);
+      
+      if (p->value || ((p->flags & BSF_UNDEFINED) !=  BSF_UNDEFINED))
+	printf ("%08lx ", (p->section ? p->value + p->section->vma : p->value));
+      else fputs ("         ", stdout);
+
+      printf ("%c %s\n", class, p->name);
+    }
+    }
+  }
+}
+
+static void
+print_symdef_entry (abfd)
+     bfd * abfd;
+{
+  symindex idx = BFD_NO_MORE_SYMBOLS;
+  carsym *thesym;
+  boolean everprinted = false;
+
+  for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
+       idx != BFD_NO_MORE_SYMBOLS;
+       idx = bfd_get_next_mapent (abfd, idx, &thesym)) {
+    bfd *elt;
+    if (!everprinted) {
+      printf ("\nArchive index:\n");
+      everprinted = true;
+    }
+    elt = bfd_get_elt_at_index (abfd, idx);
+    if (thesym->name != (char *)NULL) {
+    printf ("%s in %s\n", thesym->name, bfd_get_filename (elt));
+}
+  }
+}
diff --git a/binutils/objdump.c b/binutils/objdump.c
new file mode 100644
index 0000000..352adc3
--- /dev/null
+++ b/binutils/objdump.c
@@ -0,0 +1,714 @@
+/*** objdump.c -- dump information about an object file. */
+
+/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+
+This file is part of BFD, the Binary File Diddler.
+
+BFD is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+BFD is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with BFD; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* 
+   $Id$
+   $Log$
+   Revision 1.1  1991/03/21 21:26:48  gumby
+   Initial revision
+
+ * Revision 1.2  1991/03/15  18:34:14  rich
+ * foo
+ *
+ * Revision 1.1  1991/03/13  00:34:19  chrisb
+ * Initial revision
+ *
+ * Revision 1.9  1991/03/09  04:36:33  rich
+ *  Modified Files:
+ *  	sparc-pinsn.c ostrip.c objdump.c m68k-pinsn.c i960-pinsn.c
+ *  	binutils.h
+ *
+ * Pulled sysdep.h out of bfd.h.
+ *
+ * Revision 1.8  1991/03/09  03:42:01  rich
+ *  Modified Files:
+ *  	Makefile alloca.c ar.c i960-pinsn.c nm.c objdump.c ostrip.c
+ *  	strip.c
+ *
+ * Ports for intel960 group Portland.
+ *
+ * Revision 1.7  1991/03/08  21:54:47  rich
+ *  Modified Files:
+ *  	Makefile ar.c binutils.h bucomm.c copy.c cplus-dem.c getopt.c
+ *  	i960-pinsn.c m68k-pinsn.c nm.c objdump.c sparc-opcode.h
+ *  	sparc-pinsn.c strip.c
+ *
+ * Verifying Portland tree with steve's last changes.  Also, some partial
+ * porting.
+ *
+ * Revision 1.6  1991/03/08  07:46:26  sac
+ * Added -l option to disassembly - prints line numbers too.
+ *
+ * Revision 1.5  1991/03/07  21:50:24  sac
+ * More intelligent reloc printing
+ *
+ * Revision 1.4  1991/03/05  16:36:54  sac
+ * Fixed bug where empty symbols would print (null) on suns and crash elsewhere.
+ *
+*/
+/*
+ * Until there is other documentation, refer to the manual page dump(1) in
+ * the system 5 program's reference manual
+ */
+
+#include "sysdep.h"
+#include "bfd.h"
+#include "getopt.h"
+#include <stdio.h>
+#include <ctype.h>
+
+char *malloc();
+char *realloc();
+char *xmalloc();
+
+char *default_target = NULL;	/* default at runtime */
+
+char *program_name = NULL;
+
+int dump_section_contents;	/* -s */
+int dump_section_headers;	/* -h */
+boolean dump_file_header;	/* -f */
+int dump_symtab;		/* -t */
+int dump_reloc_info;		/* -r */
+int dump_ar_hdrs;		/* -a */
+int with_line_numbers;          /* -l */
+boolean disassemble;             /* -d */
+char *only;
+
+PROTO (void, display_file, (char *filename, char *target));
+PROTO (void, dump_data, (bfd *abfd));
+PROTO (void, dump_relocs, (bfd *abfd));
+PROTO (void, dump_symbols, (bfd *abfd));
+PROTO (void, print_arelt_descr, (bfd *abfd, boolean verbose));
+
+
+
+
+
+
+
+char *machine = (char *)NULL;
+  asymbol **syms;
+  asymbol **syms2;
+
+
+unsigned int storage;
+
+unsigned int symcount = 0;
+
+void
+usage ()
+{
+  fprintf (stderr,
+	   "usage: %s [-ahfdrtxsl] [-m machine] [-j section_name] obj ...\n",
+	   program_name);
+  exit (1);
+}
+
+static struct option long_options[] = 
+	{{"syms",   0, &dump_symtab,	      1},
+	 {"reloc",  0, &dump_reloc_info,      1},
+	 {"header", 0, &dump_section_headers, 1},
+	 {0, 0, 0, 0}};
+
+
+
+static void
+dump_headers(abfd)
+bfd *abfd;
+{
+  asection *section;
+  for (section = abfd->sections;
+       section != (asection *) NULL;
+       section = section->next) 
+    {
+      char *comma = "";
+#define PF(x,y) \
+      if (section->flags & x) {  printf("%s%s",comma,y); comma = ", "; }
+
+      printf("SECTION %d [%s]\t: size %08x",
+	     section->index,
+	     section->name,
+(unsigned)     section->size);
+      printf(" vma %08lx align 2**%2u\n ",
+	     section->vma,
+	     section->alignment_power);
+      PF(SEC_ALLOC,"ALLOC");
+      PF(SEC_LOAD,"LOAD");
+      PF(SEC_RELOC,"RELOC");
+      PF(SEC_BALIGN,"BALIGN");
+      PF(SEC_READONLY,"READONLY");
+      PF(SEC_CODE,"CODE");
+      PF(SEC_DATA,"DATA");
+      PF(SEC_ROM,"ROM");
+      printf("\n");
+#undef PF
+    }
+}
+
+static asymbol **
+slurp_symtab(abfd)
+bfd *abfd;
+{
+  asymbol **sy;
+  if (!(bfd_get_file_flags (abfd) & HAS_SYMS)) {
+    (void) printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
+    return(NULL);
+  }
+
+  storage = get_symtab_upper_bound (abfd);
+  if (storage) {
+    sy = (asymbol **) malloc (storage);
+    if (sy == NULL) {
+      fprintf (stderr, "%s: out of memory.\n", program_name);
+      exit (1);
+    }
+  }
+  symcount = bfd_canonicalize_symtab (abfd, sy);
+return sy;
+}
+/* Sort symbols into value order */
+static int comp(ap,bp)
+asymbol **ap;
+asymbol **bp;
+{
+  asymbol *a = *ap;
+  asymbol *b = *bp;
+  int diff;
+
+  if ( a->name== (char *)NULL || (a->flags &( BSF_DEBUGGING| BSF_UNDEFINED) )) 
+    a->the_bfd = 0;
+  if  ( b->name== (char *)NULL || (b->flags &( BSF_DEBUGGING|BSF_UNDEFINED))) 
+    b->the_bfd =0;
+
+  diff = a->the_bfd - b->the_bfd;
+  if (diff) {
+    return -diff;
+  }
+  diff = a->value - b->value;
+  if (diff) {
+    return diff;
+  }
+  return   a->section - b->section;
+}
+
+/* Print the supplied address symbolically if possible */
+void
+print_address(vma, stream)
+bfd_vma vma;
+FILE *stream;
+{
+  /* Perform a binary search looking for the closest symbol to
+     the required value */
+
+  unsigned int min = 0;
+  unsigned int max = symcount;
+
+  unsigned int thisplace = 1;
+  unsigned int oldthisplace ;
+
+  int vardiff;
+  if (symcount == 0)
+    fprintf(stream,"%08lx", vma);
+  else {
+    while (true) {
+      oldthisplace = thisplace;
+      thisplace = (max + min )/2  ;
+      if (thisplace == oldthisplace) break;
+
+
+	vardiff = syms[thisplace]->value - vma;
+
+      if (vardiff) {
+	if (vardiff > 0) {
+	  max = thisplace;
+	}
+	else {
+	  min = thisplace;
+	}
+      }
+      else {
+	/* Totally awesome! the exact right symbol */
+	fprintf(stream,"%08lx (%s)", vma, syms[thisplace]->name);
+	return;
+      }
+    }
+    /* We've run out of places to look, print the symbol before this one */
+    /* see if this or the symbol before describes this location the best */
+
+    if (thisplace != 0) {
+      if (syms[thisplace-1]->value - vma >
+	  syms[thisplace]->value-vma) {
+	/* Previous symbol is in correct section and is closer */
+	thisplace --;
+      }
+    }
+    
+    {
+      char *section_name;
+      asection *sec = syms[thisplace]->section;
+      if (sec) {
+	section_name = sec->name;
+      }
+      else {
+	section_name = "abs";
+      }
+    }
+    if (syms[thisplace]->value > vma) {
+      fprintf(stream,"%08lx (%s-%lx)", vma, syms[thisplace]->name,
+	      syms[thisplace]->value - vma);
+
+    }
+    else {
+      fprintf(stream,"%08lx (%s+%lx)", vma, 
+	      syms[thisplace]->name,
+	      vma - syms[thisplace]->value);
+    }
+  }
+}
+
+void
+disassemble_data(abfd)
+bfd *abfd;
+{
+  bfd_byte *data = NULL;
+  unsigned int datasize = 0;
+  unsigned int i;
+  int (*print)() ;
+  int print_insn_m68k();
+  int print_insn_i960();
+  int print_insn_sparc();
+  enum bfd_architecture a;
+  unsigned long m;
+  asection *section;
+  /* Replace symbol section relative values with abs values */
+
+  
+  for (i = 0; i < symcount; i++) {
+    if (syms[i]->section != (asection *)NULL) {
+      syms[i]->value += syms[i]->section->vma;
+    }
+  }
+
+  /* We keep a copy of the symbols in the original order */
+  syms2 = slurp_symtab(abfd);
+
+  /* Sort the symbols into section and symbol order */
+  (void)   qsort(syms, symcount, sizeof(asymbol *), comp);
+
+  /* Find the first useless symbol */
+  { unsigned int i;
+    for (i =0; i < symcount; i++) {
+      if (syms[i]->the_bfd == 0) {
+	symcount =i;
+	break;
+      }
+    }
+  }
+
+
+  if (machine!= (char *)NULL) {
+    if (bfd_scan_arch_mach(machine, &a, &m) == false) {
+      fprintf(stderr,"%s: Can't use supplied machine %s\n",
+	      program_name,
+	      machine);
+      exit(1);
+    }
+  }
+  else {
+    a =   bfd_get_architecture(abfd);
+  }
+  switch (a) {
+
+  case bfd_arch_sparc:
+    print = print_insn_sparc;
+    break;
+  case bfd_arch_m68k:
+    print = print_insn_m68k;
+    break;
+  case bfd_arch_i960:
+    print = print_insn_i960;
+    break;
+  default:
+    fprintf(stderr,"%s: Can't disassemble for architecture %s\n",
+	    program_name,
+	    bfd_printable_arch_mach(bfd_get_architecture(abfd),0));
+    exit(1);
+  }
+
+
+  for (section = abfd->sections;
+       section != (asection *)NULL;
+       section =  section->next) {
+
+    if (only == (char *)NULL || strcmp(only,section->name) == 0){
+      printf("Disassembly of section %s:\n", section->name);
+
+      if (section->size == 0) continue;
+
+      data = (bfd_byte *)malloc(section->size);
+
+      if (data == (bfd_byte *)NULL) {
+	fprintf (stderr, "%s: memory exhausted.\n", program_name);
+	exit (1);
+      }
+      datasize = section->size;
+
+
+      bfd_get_section_contents (abfd, section, data, 0, section->size);
+
+      i = 0;
+      while ((size_t)i <section->size) {
+	if (with_line_numbers) {
+	  static prevline;
+	  char *filename;
+	  char *functionname;
+	  int line;
+	  bfd_find_nearest_line(abfd,
+				section,
+				syms,
+				section->vma + i,
+				&filename,
+				&functionname,
+				&line);
+
+	  if (filename && functionname && line && line != prevline) {
+	    printf("%s:%d\n", filename, line);
+	    prevline = line;
+	  }
+	}
+	print_address(section->vma + i, stdout);
+	printf(" ");
+
+	i +=   print(section->vma + i, 
+		     data + i,
+		     stdout);
+	putchar ('\n')  ;  
+      }
+
+
+
+
+      free(data);
+    }
+  }
+}
+
+void
+display_bfd (abfd)
+     bfd *abfd;
+{
+
+  if (!bfd_check_format (abfd, bfd_object)) {
+    fprintf (stderr,"%s: %s not an object file\n", program_name,
+	     abfd->filename);
+    return;
+  }
+  printf ("\n%s:     file format %s\n", abfd->filename, abfd->xvec->name);
+  if (dump_ar_hdrs) print_arelt_descr (abfd, true);
+
+  if (dump_file_header) {
+    char *comma = "";
+
+    printf("architecture: %s, ",
+	   bfd_printable_arch_mach (bfd_get_architecture (abfd),
+				    bfd_get_machine (abfd)));
+    printf("flags 0x%08x:\n", abfd->flags);
+    
+#define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
+    PF(HAS_RELOC, "HAS_RELOC");
+    PF(EXEC_P, "EXEC_P");
+    PF(HAS_LINENO, "HAS_LINENO");
+    PF(HAS_DEBUG, "HAS_DEBUG");
+    PF(HAS_SYMS, "HAS_SYMS");
+    PF(HAS_LOCALS, "HAS_LOCALS");
+    PF(DYNAMIC, "DYNAMIC");
+    PF(WP_TEXT, "WP_TEXT");
+    PF(D_PAGED, "D_PAGED");
+    printf("\nstart address 0x%08lx", abfd->start_address);
+  }
+  printf("\n");
+
+  if (dump_section_headers)
+    dump_headers(abfd);
+  if (dump_symtab || dump_reloc_info || disassemble) {
+syms =  slurp_symtab(abfd);
+  }
+  if (dump_symtab) dump_symbols (abfd);
+  if (dump_reloc_info) dump_relocs(abfd);
+  if (dump_section_contents) dump_data (abfd);
+  if (disassemble) disassemble_data(abfd);
+}
+
+void
+display_file (filename, target)
+     char *filename;
+     char *target;
+{
+  bfd *file, *arfile = (bfd *) NULL;
+
+  file = bfd_openr (filename, target);
+  if (file == NULL) {
+    bfd_perror (filename);
+    return;
+  }
+
+  if (bfd_check_format (file, bfd_archive) == true) {
+    printf ("In archive %s:\n", bfd_get_filename (file));
+    for(;;) {
+      bfd_error = no_error;
+
+      arfile = bfd_openr_next_archived_file (file, arfile);
+      if (arfile == NULL) {
+	if (bfd_error != no_more_archived_files)
+	  bfd_perror (bfd_get_filename(file));
+	return;
+      }
+
+      display_bfd (arfile);
+      /* Don't close the archive elements; we need them for next_archive */
+    }
+  }
+  else
+    display_bfd(file);
+
+  bfd_close(file);
+}
+
+/* Actually display the various requested regions */
+
+
+
+
+
+
+
+
+
+
+void
+dump_data (abfd)
+     bfd *abfd;
+{
+  asection *section;
+  bfd_byte  *data ;
+  unsigned int datasize = 0;
+  size_t i;
+
+  for (section = abfd->sections; section != NULL; section =
+       section->next) {
+    int onaline = 16;
+
+    if (only == (char *)NULL || 
+	strcmp(only,section->name) == 0){
+
+
+
+      printf("Contents of section %s:\n", section->name);
+
+      if (section->size == 0) continue;
+      data = (bfd_byte *)malloc(section->size);
+      if (data == (bfd_byte *)NULL) {
+	fprintf (stderr, "%s: memory exhausted.\n", program_name);
+	exit (1);
+      }
+      datasize = section->size;
+
+
+      bfd_get_section_contents (abfd, section, data, 0, section->size);
+
+      for (i= 0; i < section->size; i += onaline) {
+	size_t j;
+	printf(" %04lx ", i + section->vma);
+	for (j = i; j < i+ onaline; j++) {
+	  if (j < section->size)
+	    printf("%02x", (unsigned)(data[j]));
+	  else 
+	    printf("  ");
+	  if ((j & 3 ) == 3) printf(" ");
+	}
+
+	printf(" ");
+	for (j = i; j < i+onaline ; j++) {
+	  if (j >= section->size)
+	    printf(" ");
+	  else
+	    printf("%c", isprint(data[j]) ?data[j] : '.');
+	}
+	putchar ('\n');
+      }
+    }
+
+    free (data);
+  }
+}
+
+
+
+/* Should perhaps share code and display with nm? */
+void
+dump_symbols (abfd)
+     bfd *abfd;
+{
+
+  unsigned int count;
+  asymbol **current = syms;
+  printf("SYMBOL TABLE:\n");
+
+  for (count = 0; count < symcount; count++) {
+    if ((*current)->the_bfd) {
+      bfd_print_symbol((*current)->the_bfd,
+		       stdout,
+		       *current, bfd_print_symbol_all_enum);
+
+      printf("\n");
+    }
+    current++;
+  }
+  printf("\n");
+  printf("\n");
+}
+
+
+void
+dump_relocs(abfd)
+bfd *abfd;
+{
+  arelent **relpp;
+  unsigned int relcount;
+  asection *a;
+  for (a = abfd->sections; a != (asection *)NULL; a = a->next) {
+    printf("RELOCATION RECORDS FOR [%s]:",a->name);
+    
+    if (get_reloc_upper_bound(abfd, a) == 0) {
+      printf(" (none)\n\n");
+    }
+    else {
+      arelent **p;
+
+      relpp = (arelent **) xmalloc( get_reloc_upper_bound(abfd,a) );
+      relcount = bfd_canonicalize_reloc(abfd,a,relpp, syms);
+      if (relcount == 0) {
+	printf(" (none)\n\n");
+      }
+      else {
+	printf("\n");
+	printf("OFFSET   TYPE      VALUE \n");
+
+	for (p =relpp; *p != (arelent *)NULL; p++) {
+	  arelent *q = *p;
+	  char *sym_name;
+	  char *section_name =	    q->section == (asection *)NULL ? "*abs" :
+	  q->section->name;
+	  if (q->sym_ptr_ptr && *q->sym_ptr_ptr) {
+	    sym_name =  (*(q->sym_ptr_ptr))->name ;
+	  }
+	  else {
+	    sym_name = 0;
+	  }
+	  if (sym_name) {
+	    printf("%08lx %-8s  %s",
+		   q->address,
+		   q->howto->name,
+		   sym_name);
+	  }
+	  else {
+	    printf("%08lx %-8s  [%s]",
+		   q->address,
+		   q->howto->name,
+		   section_name);
+	  }
+	  if (q->addend) {
+	    printf("+0x%lx(%ld)", q->addend, (long) q->addend);
+	  }
+	  printf("\n");
+	}
+	printf("\n\n");
+	free(relpp);
+      }
+    }
+
+  }
+}
+
+
+/** main and like trivia */
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  extern int optind;
+  extern char *optarg;
+  char *target = default_target;
+  boolean seenflag = false;
+  int ind = 0;
+
+  program_name = *argv;
+
+  while ((c = getopt_long (argc, argv, "b:m:dlfahrtxsj:", long_options, &ind))
+	 != EOF) {
+    seenflag = true;
+    switch (c) {
+    case 'm':
+      machine = optarg;
+      break;
+    case 'j':
+      only = optarg;
+      break;
+    case 'l':
+      with_line_numbers = 1;
+      break;
+    case 'b':
+      target = optarg;
+      break;
+    case 'f':
+      dump_file_header = true;
+      break;
+    case 'x':
+      dump_symtab = 1; 
+      dump_reloc_info = 1;
+      dump_file_header = true;
+      dump_ar_hdrs = 1;
+      dump_section_headers = 1;
+      break;
+    case  0 : break;		/* we've been given a long option */
+    case 't': dump_symtab = 1; break;
+    case 'd': disassemble = true ; break;
+    case 's': dump_section_contents = 1; break;
+    case 'r': dump_reloc_info = 1; break;
+    case 'a': dump_ar_hdrs = 1; break;
+    case 'h': dump_section_headers = 1; break;
+    default:
+      usage ();
+    }
+  }
+
+  if (seenflag == false)
+    usage ();
+
+  if (optind == argc)
+    display_file ("a.out", target);
+  else
+    for (; optind < argc;)
+      display_file (argv[optind++], target);
+  return 0;
+}
diff --git a/binutils/size.c b/binutils/size.c
new file mode 100644
index 0000000..9f6800c
--- /dev/null
+++ b/binutils/size.c
@@ -0,0 +1,320 @@
+/*** size.c -- report size of various sections of an executable file */
+/* Extensions/incompatibilities:
+   o - BSD output has filenames at the end.
+   o - BSD output can appear in different radicies.
+   o - SysV output has less redundant whitespace.  Filename comes at end.
+   o - SysV output doesn't show VMA which is always the same as the PMA.
+   o - We also handle core files.
+   o - We also handle archives.
+   If you write shell scripts which manipulate this info then you may be
+   out of luck; there's no +predantic switch.
+*/
+#include "sysdep.h"
+#include "bfd.h"
+#include "getopt.h"
+
+
+#ifndef BSD_DEFAULT
+#define BSD_DEFAULT 1
+#endif
+
+PROTO(void, display_file, (char *filename));
+PROTO(void, print_sizes,  (bfd *file));
+
+/* Various program options */
+
+enum {decimal, octal, hex} radix = decimal;
+int berkeley_format = BSD_DEFAULT; /* 0 means use AT&T-style output */
+int show_version = 0;
+int show_help = 0;
+
+/* IMPORTS */
+extern char *program_version;
+extern char *program_name;
+extern char *target;
+
+/** main and like trivia */
+
+void
+usage ()
+{
+  fprintf (stderr, "size %s\nUsage: %s -{dox}{AB}V files ...\n",
+	 program_version, program_name);
+  fputs("\t+radix={8|10|16} -- select appropriate output radix.\n\
+\t-d -- output in decimal\n\
+\t-o -- output in octal\n\
+\t-x -- output in hex", stderr);
+  fputs("\t+format={Berkeley|SysV} -- select display format.\n\
+\t-A -- SysV(AT&T) format\n\
+\t-B -- BSD format", stderr);
+#if BSD_DEFAULT
+  fputs("\t  (Default is +format=Berkeley)", stderr);
+#else
+  fputs("\t  (Default is +format=SysV)", stderr);
+#endif
+  fputs("\t-V, +version -- display program version, etc.\n\
+\t+help -- this message\n", stderr);
+  exit(1);
+}
+
+struct option long_options[] = {{"radix",   1, 0, 0},
+				{"format",  1, 0, 0},
+				{"version", 0, &show_version, 1},
+				{"target",  2, NULL, NULL},
+				{"help",    0, &show_help, 1},
+				{0, 0, 0, 0}};
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int temp;
+  int c;			/* sez which option char */
+  int option_index = 0;
+  extern int optind;		/* steps thru options */
+  program_name = *argv;
+
+  while ((c = getopt_long(argc, argv, "ABVdox", long_options,
+			  &option_index)) != EOF)
+    switch(c) {
+    case 0:
+      if (!strcmp("format",(long_options[option_index]).name)) {
+	switch(*optarg) {
+	case 'B': case 'b': berkeley_format = 1; break;
+	case 'S': case 's': berkeley_format = 0; break;
+	default: printf("Unknown option to +format: %s\n", optarg);
+	  usage();
+	}
+	break;
+      }
+
+      if (!strcmp("target",(long_options[option_index]).name)) {
+	target = optarg;
+	break;
+      }
+
+      if (!strcmp("radix",(long_options[option_index]).name)) {
+#ifdef ANSI_LIBRARIES
+	temp = strtol(optarg, NULL, 10);
+#else
+	temp = atol(optarg);
+#endif
+	switch(temp) {
+	case 10: radix = decimal; break;
+	case 8:  radix = octal; break;
+	case 16: radix = hex; break;
+	default: printf("Unknown radix: %s\n", optarg);
+	  usage();
+	}
+      }
+      break;
+    case 'A': berkeley_format = 0; break;
+    case 'B': berkeley_format = 1; break;
+    case 'V': show_version = 1; break;
+    case 'd': radix = decimal; break;
+    case 'x': radix = hex; break;
+    case 'o': radix = octal; break;
+    case '?': usage();
+    }
+
+  if (show_version) printf("%s version %s\n", program_name, program_version);
+  if (show_help) usage();
+	
+  if (berkeley_format)
+#if 0	/* intel doesn't like bss/stk b/c they don't gave core files */
+    puts((radix == octal) ? "text\tdata\tbss/stk\toct\thex\tfilename" :
+	 "text\tdata\tbss/stk\tdec\thex\tfilename");
+#else
+    puts((radix == octal) ? "text\tdata\tbss\toct\thex\tfilename" :
+	 "text\tdata\tbss\tdec\thex\tfilename");
+#endif
+  if (optind == argc)
+    display_file ("a.out");
+  else
+    for (; optind < argc;)
+      display_file (argv[optind++]);
+
+  return 0;
+}
+
+/** Display a file's stats */
+
+void
+display_bfd (abfd)
+     bfd *abfd;
+{
+  char *core_cmd;
+
+  if (bfd_check_format(abfd, bfd_archive)) return;
+
+  if (bfd_check_format(abfd, bfd_object)) {
+    print_sizes(abfd);
+    goto done;
+  }
+
+  if (bfd_check_format(abfd, bfd_core)) {
+    print_sizes(abfd);
+    fputs(" (core file", stdout);
+
+    core_cmd = bfd_core_file_failing_command(abfd);
+    if (core_cmd) printf(" invoked as %s", core_cmd);
+
+    puts(")");
+    goto done;
+  }
+  
+  printf("Unknown file format: %s.", bfd_get_filename(abfd));
+
+ done:
+
+
+  printf("\n");
+  return;
+}
+
+void
+display_file(filename)
+     char *filename;
+{
+  bfd *file, *arfile = (bfd *) NULL;
+
+  file = bfd_openr (filename, target);
+  if (file == NULL) {
+    bfd_perror (filename);
+    return;
+  }
+
+  if (bfd_check_format(file, bfd_archive) == true) {
+    for(;;) {
+      
+      bfd_error = no_error;
+
+       arfile = bfd_openr_next_archived_file (file, arfile);
+      if (arfile == NULL) {
+	if (bfd_error != no_more_archived_files)
+	  bfd_perror (bfd_get_filename (file));
+	return;
+      }
+
+      display_bfd (arfile);
+      /* Don't close the archive elements; we need them for next_archive */
+    }
+  }
+  else
+    display_bfd (file);
+
+  bfd_close (file);
+}
+
+/* This is what lexical functions are for */
+void
+lprint_number (width, num)
+     int width, num;
+{
+  printf ((radix == decimal ? "%-*d\t" :
+	   ((radix == octal) ? "%-*o\t" : "%-*x\t")), width, num);
+}
+
+void
+rprint_number(width, num)
+     int width, num;
+{
+  printf ((radix == decimal ? "%*d\t" :
+	   ((radix == octal) ? "%*o\t" : "%*x\t")), width, num);
+}
+
+static char *bss_section_name = ".bss";
+static char *data_section_name = ".data";
+static char *stack_section_name = ".stack";
+static char *text_section_name = ".text";
+
+void print_berkeley_format(abfd)
+bfd *abfd;
+{
+  sec_ptr bsssection = NULL;
+  sec_ptr datasection = NULL;
+  sec_ptr textsection = NULL;
+  unsigned long bsssize = 0;
+  unsigned long datasize = 0;
+  unsigned long textsize = 0;
+  unsigned long total = 0;
+
+  
+  if ((textsection = bfd_get_section_by_name (abfd, text_section_name))
+      != NULL) {
+    textsize = bfd_section_size (abfd, textsection);
+  }
+
+  if ((datasection = bfd_get_section_by_name (abfd, data_section_name))
+      != NULL) {
+    datasize = bfd_section_size(abfd, datasection);
+  }
+	
+  if (bfd_get_format (abfd) == bfd_object) {
+    if ((bsssection = bfd_get_section_by_name (abfd, bss_section_name))
+	!= NULL) {
+      bsssize = bfd_section_size(abfd, bsssection);
+    }
+  } else {
+    if ((bsssection = bfd_get_section_by_name (abfd, stack_section_name))
+	!= NULL) {
+      bsssize = bfd_section_size(abfd, bsssection);
+    }
+  }
+	
+  total = textsize + datasize + bsssize;
+	
+  lprint_number (7, textsize);
+  lprint_number (7, datasize);
+  lprint_number (7, bsssize);
+  printf (((radix == octal) ? "%-7o\t%-7x\t" : "%-7d\t%-7x\t"), total, total);
+
+  fputs(bfd_get_filename(abfd), stdout);
+  if (abfd->my_archive) printf (" (ex %s)", abfd->my_archive->filename);
+}
+
+/* I REALLY miss lexical functions! */
+int svi_total = 0;
+
+void
+sysv_internal_printer(file, sec)
+     bfd *file;
+     sec_ptr sec;
+{
+  int size = bfd_section_size (file, sec);
+
+  svi_total += size;
+	
+  printf ("%-12s", bfd_section_name(file, sec));
+  rprint_number (8, size);
+  printf(" ");
+  rprint_number (8, bfd_section_vma(file, sec));
+  printf ("\n");
+}
+
+void
+print_sysv_format(file)
+     bfd *file;
+{
+  svi_total = 0;
+
+  printf ("%s  ", bfd_get_filename (file));
+  if (file->my_archive) printf (" (ex %s)", file->my_archive->filename);
+
+  puts(":\nsection\t\tsize\t     addr");
+  bfd_map_over_sections (file, sysv_internal_printer, NULL);
+
+  printf("Total       ");
+  rprint_number(8, svi_total);
+  printf("\n");  printf("\n");
+}
+
+void
+print_sizes(file)
+     bfd *file;
+{
+  if (berkeley_format)
+    print_berkeley_format(file);
+  else print_sysv_format(file);
+}
diff --git a/binutils/sparc-pinsn.c b/binutils/sparc-pinsn.c
new file mode 100644
index 0000000..550722b
--- /dev/null
+++ b/binutils/sparc-pinsn.c
@@ -0,0 +1,490 @@
+/* disassemble sparc instructions for objdump
+   Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
+
+
+This file is part of the binutils.
+
+The binutils are free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+The binutils are distributed in the hope that they will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the binutils; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* $Id$
+   $Log$
+   Revision 1.1  1991/03/21 21:26:55  gumby
+   Initial revision
+
+ * Revision 1.1  1991/03/13  00:34:40  chrisb
+ * Initial revision
+ *
+ * Revision 1.3  1991/03/09  04:36:31  rich
+ *  Modified Files:
+ *  	sparc-pinsn.c ostrip.c objdump.c m68k-pinsn.c i960-pinsn.c
+ *  	binutils.h
+ *
+ * Pulled sysdep.h out of bfd.h.
+ *
+ * Revision 1.2  1991/03/08  21:54:53  rich
+ *  Modified Files:
+ *  	Makefile ar.c binutils.h bucomm.c copy.c cplus-dem.c getopt.c
+ *  	i960-pinsn.c m68k-pinsn.c nm.c objdump.c sparc-opcode.h
+ *  	sparc-pinsn.c strip.c
+ *
+ * Verifying Portland tree with steve's last changes.  Also, some partial
+ * porting.
+ *
+ * Revision 1.1  1991/02/22  16:48:04  sac
+ * Initial revision
+ *
+*/
+
+#include <stdio.h>
+#include "sysdep.h"
+#include "bfd.h"
+#include "sparc-opcode.h"
+
+extern int fputs();
+extern int print_address();
+
+static  char *reg_names[] =
+ { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",	
+  "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",	
+  "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",	
+  "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",	
+  "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",	
+  "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",	
+  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
+  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
+  "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr" };
+
+#define	freg_names	(&reg_names[4 * 8])
+
+union sparc_insn
+  {
+    unsigned long int code;
+    struct
+      {
+	unsigned int OP:2;
+#define	op	ldst.OP
+	unsigned int RD:5;
+#define	rd	ldst.RD
+	unsigned int op3:6;
+	unsigned int RS1:5;
+#define	rs1	ldst.RS1
+	unsigned int i:1;
+	unsigned int ASI:8;
+#define	asi	ldst.ASI
+	unsigned int RS2:5;
+#define	rs2	ldst.RS2
+#define	shcnt	rs2
+      } ldst;
+    struct
+      {
+	unsigned int OP:2, RD:5, op3:6, RS1:5, i:1;
+	unsigned int IMM13:13;
+#define	imm13	IMM13.IMM13
+      } IMM13;
+    struct
+      {
+	unsigned int OP:2;
+	unsigned int a:1;
+	unsigned int cond:4;
+	unsigned int op2:3;
+	unsigned int DISP22:22;
+#define	disp22	branch.DISP22
+      } branch;
+#define	imm22	disp22
+    struct
+      {
+	unsigned int OP:2;
+	unsigned int DISP30:30;
+#define	disp30	call.DISP30
+      } call;
+  };
+
+/* Nonzero if INSN is the opcode for a delayed branch.  */
+static int
+is_delayed_branch (insn)
+     union sparc_insn insn;
+{
+  unsigned int i;
+
+  for (i = 0; i < NUMOPCODES; ++i)
+    {
+      const struct sparc_opcode *opcode = &sparc_opcodes[i];
+      if ((opcode->match & insn.code) == opcode->match
+	  && (opcode->lose & insn.code) == 0
+	  && (opcode->delayed))
+	return 1;
+    }
+  return 0;
+}
+
+static int opcodes_sorted = 0;
+
+/* Print one instruction from MEMADDR on STREAM.  */
+int
+print_insn_sparc (memaddr, buffer,  stream)
+     bfd_vma memaddr;
+    bfd_byte  *buffer;
+     FILE *stream;
+     
+{
+  union sparc_insn insn;
+
+  register unsigned int i;
+
+  if (!opcodes_sorted)
+    {
+      static int compare_opcodes ();
+      qsort ((char *) sparc_opcodes, NUMOPCODES,
+	     sizeof (sparc_opcodes[0]), compare_opcodes);
+      opcodes_sorted = 1;
+    }
+
+memcpy(&insn,buffer, sizeof (insn));
+
+  for (i = 0; i < NUMOPCODES; ++i)
+    {
+      const struct sparc_opcode *opcode = &sparc_opcodes[i];
+      if ((opcode->match & insn.code) == opcode->match
+	  && (opcode->lose & insn.code) == 0)
+	{
+	  /* Nonzero means that we have found an instruction which has
+	     the effect of adding or or'ing the imm13 field to rs1.  */
+	  int imm_added_to_rs1 = 0;
+
+	  /* Nonzero means that we have found a plus sign in the args
+	     field of the opcode table.  */
+	  int found_plus = 0;
+	  
+	  /* Do we have an 'or' instruction where rs1 is the same
+	     as rsd, and which has the i bit set?  */
+	  if (opcode->match == 0x80102000
+	      && insn.rs1 == insn.rd)
+	    imm_added_to_rs1 = 1;
+
+	  if (index (opcode->args, 'S') != 0)
+	    /* Reject the special case for `set'.
+	       The real `sethi' will match.  */
+	    continue;
+	  if (insn.rs1 != insn.rd
+	      && index (opcode->args, 'r') != 0)
+	      /* Can't do simple format if source and dest are different.  */
+	      continue;
+
+	  fputs (opcode->name, stream);
+
+	  {
+	    register const char *s;
+
+	    if (opcode->args[0] != ',')
+	      fputs (" ", stream);
+	    for (s = opcode->args; *s != '\0'; ++s)
+	      {
+		if (*s == ',')
+		  {
+		    fputs (",", stream);
+		    ++s;
+		    if (*s == 'a')
+		      {
+			fputs ("a", stream);
+			++s;
+		      }
+		    fputs (" ", stream);
+		  }
+
+		switch (*s)
+		  {
+		  case '+':
+		    found_plus = 1;
+
+		    /* note fall-through */
+		  default:
+		    fprintf (stream, "%c", *s);
+		    break;
+
+		  case '#':
+		    fputs ("0", stream);
+		    break;
+
+#define	reg(n)	fprintf (stream, "%%%s", reg_names[n])
+		  case '1':
+		  case 'r':
+		    reg (insn.rs1);
+		    break;
+
+		  case '2':
+		    reg (insn.rs2);
+		    break;
+
+		  case 'd':
+		    reg (insn.rd);
+		    break;
+#undef	reg
+
+#define	freg(n)	fprintf (stream, "%%%s", freg_names[n])
+		  case 'e':
+		    freg (insn.rs1);
+		    break;
+
+		  case 'f':
+		    freg (insn.rs2);
+		    break;
+
+		  case 'g':
+		    freg (insn.rd);
+		    break;
+#undef	freg
+
+#define	creg(n)	fprintf (stream, "%%c%u", (unsigned int) (n))
+		  case 'b':
+		    creg (insn.rs1);
+		    break;
+
+		  case 'c':
+		    creg (insn.rs2);
+		    break;
+
+		  case 'D':
+		    creg (insn.rd);
+		    break;
+#undef	creg
+
+		  case 'h':
+		    fprintf (stream, "%%hi(%#x)",
+				      (unsigned int) insn.imm22 << 10);
+		    break;
+
+		  case 'i':
+		    {
+		      /* We cannot trust the compiler to sign-extend
+			 when extracting the bitfield, hence the shifts.  */
+		      int imm = ((int) insn.imm13 << 19) >> 19;
+
+		      /* Check to see whether we have a 1+i, and take
+			 note of that fact.
+
+			 Note: because of the way we sort the table,
+			 we will be matching 1+i rather than i+1,
+			 so it is OK to assume that i is after +,
+			 not before it.  */
+		      if (found_plus)
+			imm_added_to_rs1 = 1;
+		      
+		      if (imm <= 9)
+			fprintf (stream, "%d", imm);
+		      else
+			fprintf (stream, "%#x", (unsigned) imm);
+		    }
+		    break;
+
+		  case 'L':
+		    print_address ((bfd_vma) memaddr + insn.disp30 * 4,
+				   stream);
+		    break;
+
+		  case 'l':
+		    if ((insn.code >> 22) == 0)
+		      /* Special case for `unimp'.  Don't try to turn
+			 it's operand into a function offset.  */
+		      fprintf (stream, "%#x",
+					(unsigned) (((int) insn.disp22 << 10) >> 10));
+		    else
+		      /* We cannot trust the compiler to sign-extend
+			 when extracting the bitfield, hence the shifts.  */
+		      print_address ((bfd_vma)
+				     (memaddr
+				      + (((int) insn.disp22 << 10) >> 10) * 4),
+				     stream);
+		    break;
+
+		  case 'A':
+		    fprintf (stream, "(%d)", (int) insn.asi);
+		    break;
+
+		  case 'C':
+		    fputs ("%csr", stream);
+		    break;
+
+		  case 'F':
+		    fputs ("%fsr", stream);
+		    break;
+
+		  case 'p':
+		    fputs ("%psr", stream);
+		    break;
+
+		  case 'q':
+		    fputs ("%fq", stream);
+		    break;
+
+		  case 'Q':
+		    fputs ("%cq", stream);
+		    break;
+
+		  case 't':
+		    fputs ("%tbr", stream);
+		    break;
+
+		  case 'w':
+		    fputs ("%wim", stream);
+		    break;
+
+		  case 'y':
+		    fputs ("%y", stream);
+		    break;
+		  }
+	      }
+	  }
+
+	  /* If we are adding or or'ing something to rs1, then
+	     check to see whether the previous instruction was
+	     a sethi to the same register as in the sethi.
+	     If so, attempt to print the result of the add or
+	     or (in this context add and or do the same thing)
+	     and its symbolic value.  */
+	  if (imm_added_to_rs1)
+	    {
+	      union sparc_insn prev_insn;
+	      int errcode;
+
+	      memcpy(&prev_insn, buffer -4,  sizeof (prev_insn));
+
+	      if (errcode == 0)
+		{
+		  /* If it is a delayed branch, we need to look at the
+		     instruction before the delayed branch.  This handles
+		     sequences such as
+
+		     sethi %o1, %hi(_foo), %o1
+		     call _printf
+		     or %o1, %lo(_foo), %o1
+		     */
+
+		  if (is_delayed_branch (prev_insn))
+		    memcpy(&prev_insn, buffer - 8, sizeof(prev_insn));
+
+		}
+
+	      /* If there was a problem reading memory, then assume
+		 the previous instruction was not sethi.  */
+	      if (errcode == 0)
+		{
+		  /* Is it sethi to the same register?  */
+		  if ((prev_insn.code & 0xc1c00000) == 0x01000000
+		      && prev_insn.rd == insn.rs1)
+		    {
+		      fprintf (stream, "\t! ");
+		      /* We cannot trust the compiler to sign-extend
+			 when extracting the bitfield, hence the shifts.  */
+		      print_address (((int) prev_insn.imm22 << 10)
+				     | (insn.imm13 << 19) >> 19, stream);
+		    }
+		}
+	    }
+
+	  return sizeof (insn);
+	}
+    }
+
+  fprintf ("%#8x", insn.code);
+  return sizeof (insn);
+}
+
+
+/* Compare opcodes A and B.  */
+
+static int
+compare_opcodes (a, b)
+     char *a, *b;
+{
+  struct sparc_opcode *op0 = (struct sparc_opcode *) a;
+  struct sparc_opcode *op1 = (struct sparc_opcode *) b;
+  unsigned long int match0 = op0->match, match1 = op1->match;
+  unsigned long int lose0 = op0->lose, lose1 = op1->lose;
+  register unsigned int i;
+
+  /* If a bit is set in both match and lose, there is something
+     wrong with the opcode table.  */
+  if (match0 & lose0)
+    {
+      fprintf (stderr, "Internal error:  bad sparc-opcode.h: \"%s\", %#.8lx, %#.8lx\n",
+	       op0->name, match0, lose0);
+      op0->lose &= ~op0->match;
+      lose0 = op0->lose;
+    }
+
+  if (match1 & lose1)
+    {
+      fprintf (stderr, "Internal error: bad sparc-opcode.h: \"%s\", %#.8lx, %#.8lx\n",
+	       op1->name, match1, lose1);
+      op1->lose &= ~op1->match;
+      lose1 = op1->lose;
+    }
+
+  /* Because the bits that are variable in one opcode are constant in
+     another, it is important to order the opcodes in the right order.  */
+  for (i = 0; i < 32; ++i)
+    {
+      unsigned long int x = 1 << i;
+      int x0 = (match0 & x) != 0;
+      int x1 = (match1 & x) != 0;
+
+      if (x0 != x1)
+	return x1 - x0;
+    }
+
+  for (i = 0; i < 32; ++i)
+    {
+      unsigned long int x = 1 << i;
+      int x0 = (lose0 & x) != 0;
+      int x1 = (lose1 & x) != 0;
+
+      if (x0 != x1)
+	return x1 - x0;
+    }
+
+  /* They are functionally equal.  So as long as the opcode table is
+     valid, we can put whichever one first we want, on aesthetic grounds.  */
+  {
+    int length_diff = strlen (op0->args) - strlen (op1->args);
+    if (length_diff != 0)
+      /* Put the one with fewer arguments first.  */
+      return length_diff;
+  }
+
+  /* Put 1+i before i+1.  */
+  {
+    char *p0 = (char *) index(op0->args, '+');
+    char *p1 = (char *) index(op1->args, '+');
+
+    if (p0 && p1)
+      {
+	/* There is a plus in both operands.  Note that a plus
+	   sign cannot be the first character in args,
+	   so the following [-1]'s are valid.  */
+	if (p0[-1] == 'i' && p1[1] == 'i')
+	  /* op0 is i+1 and op1 is 1+i, so op1 goes first.  */
+	  return 1;
+	if (p0[1] == 'i' && p1[-1] == 'i')
+	  /* op0 is 1+i and op1 is i+1, so op0 goes first.  */
+	  return -1;
+      }
+  }
+
+  /* They are, as far as we can tell, identical.
+     Since qsort may have rearranged the table partially, there is
+     no way to tell which one was first in the opcode table as
+     written, so just say there are equal.  */
+  return 0;
+}
diff --git a/binutils/version.c b/binutils/version.c
new file mode 100644
index 0000000..d3e5a132
--- /dev/null
+++ b/binutils/version.c
@@ -0,0 +1,5 @@
+/*** version.c -- version number for binutils.
+     They all change in lockstep -- it's easier that way
+*/
+
+char *program_version = "1.10 (Cygnus BFD)";