X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Fbucomm.c;h=6573e2d9c7fa09ff610cd869bd2937048f706303;hb=69b975477d1abc861452d7cb2c82190e44c47a94;hp=6b4223c2b9fb47551b75772f06f060f09c382ef2;hpb=e98fe4f7b54cbdf29aef9287bbb1bea8801dd05a;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/bucomm.c b/binutils/bucomm.c index 6b4223c2b9..6573e2d9c7 100644 --- a/binutils/bucomm.c +++ b/binutils/bucomm.c @@ -1,5 +1,6 @@ /* bucomm.c -- Bin Utils COMmon code. - Copyright (C) 1991, 92, 93, 94, 95, 1997 Free Software Foundation, Inc. + Copyright 1991, 1992, 1993, 1994, 1995, 1997, 1998, 2000, 2001, 2002, 2003 + Free Software Foundation, Inc. This file is part of GNU Binutils. @@ -22,8 +23,11 @@ loaded, but for now it's not necessary. */ #include "bfd.h" +#include "bfdver.h" #include "libiberty.h" #include "bucomm.h" +#include "filenames.h" +#include "libbfd.h" #include #include /* ctime, maybe time_t */ @@ -34,23 +38,19 @@ typedef long time_t; #endif #endif -#ifdef ANSI_PROTOTYPES -#include -#else -#include -#endif - -char *target = NULL; /* default as late as possible */ +static const char * endian_string (enum bfd_endian); +static int display_target_list (void); +static int display_info_table (int, int); +static int display_target_tables (void); -/* Error reporting */ +/* Error reporting. */ char *program_name; void -bfd_nonfatal (string) - CONST char *string; +bfd_nonfatal (const char *string) { - CONST char *errmsg = bfd_errmsg (bfd_get_error ()); + const char *errmsg = bfd_errmsg (bfd_get_error ()); if (string) fprintf (stderr, "%s: %s: %s\n", program_name, string, errmsg); @@ -59,43 +59,40 @@ bfd_nonfatal (string) } void -bfd_fatal (string) - CONST char *string; +bfd_fatal (const char *string) { bfd_nonfatal (string); xexit (1); } -#ifdef ANSI_PROTOTYPES void -fatal (const char *format, ...) +report (const char * format, va_list args) { - va_list args; - fprintf (stderr, "%s: ", program_name); - va_start (args, format); vfprintf (stderr, format, args); - va_end (args); putc ('\n', stderr); - xexit (1); } -#else -void -fatal (va_alist) - va_dcl + +void +fatal VPARAMS ((const char *format, ...)) { - char *Format; - va_list args; + VA_OPEN (args, format); + VA_FIXEDARG (args, const char *, format); - fprintf (stderr, "%s: ", program_name); - va_start (args); - Format = va_arg (args, char *); - vfprintf (stderr, Format, args); - va_end (args); - putc ('\n', stderr); + report (format, args); + VA_CLOSE (args); xexit (1); } -#endif + +void +non_fatal VPARAMS ((const char *format, ...)) +{ + VA_OPEN (args, format); + VA_FIXEDARG (args, const char *, format); + + report (format, args); + VA_CLOSE (args); +} /* Set the default BFD target based on the configured target. Doing this permits the binutils to be configured for a particular target, @@ -103,63 +100,264 @@ fatal (va_alist) different target. */ void -set_default_bfd_target () +set_default_bfd_target (void) { /* The macro TARGET is defined by Makefile. */ const char *target = TARGET; if (! bfd_set_default_target (target)) - { - char *errmsg; - - errmsg = (char *) xmalloc (100 + strlen (target)); - sprintf (errmsg, "can't set BFD default target to `%s'", target); - bfd_fatal (errmsg); - } + fatal (_("can't set BFD default target to `%s': %s"), + target, bfd_errmsg (bfd_get_error ())); } -/* After a false return from bfd_check_format_matches with +/* After a FALSE return from bfd_check_format_matches with bfd_get_error () == bfd_error_file_ambiguously_recognized, print the possible matching targets. */ void -list_matching_formats (p) - char **p; +list_matching_formats (char **p) { - fprintf(stderr, "%s: Matching formats:", program_name); + fprintf (stderr, _("%s: Matching formats:"), program_name); while (*p) - fprintf(stderr, " %s", *p++); - fprintf(stderr, "\n"); + fprintf (stderr, " %s", *p++); + fputc ('\n', stderr); } /* List the supported targets. */ void -list_supported_targets (name, f) - const char *name; - FILE *f; +list_supported_targets (const char *name, FILE *f) { - extern bfd_target *bfd_target_vector[]; int t; + const char **targ_names = bfd_target_list (); + + if (name == NULL) + fprintf (f, _("Supported targets:")); + else + fprintf (f, _("%s: supported targets:"), name); + + for (t = 0; targ_names[t] != NULL; t++) + fprintf (f, " %s", targ_names[t]); + fprintf (f, "\n"); + free (targ_names); +} + +/* List the supported architectures. */ + +void +list_supported_architectures (const char *name, FILE *f) +{ + const char **arch; if (name == NULL) - fprintf (f, "Supported targets:"); + fprintf (f, _("Supported architectures:")); else - fprintf (f, "%s: supported targets:", name); - for (t = 0; bfd_target_vector[t] != NULL; t++) - fprintf (f, " %s", bfd_target_vector[t]->name); + fprintf (f, _("%s: supported architectures:"), name); + + for (arch = bfd_arch_list (); *arch; arch++) + fprintf (f, " %s", *arch); fprintf (f, "\n"); } +/* The length of the longest architecture name + 1. */ +#define LONGEST_ARCH sizeof ("powerpc:common") + +static const char * +endian_string (enum bfd_endian endian) +{ + switch (endian) + { + case BFD_ENDIAN_BIG: return "big endian"; + case BFD_ENDIAN_LITTLE: return "little endian"; + default: return "endianness unknown"; + } +} + +/* List the targets that BFD is configured to support, each followed + by its endianness and the architectures it supports. */ + +static int +display_target_list (void) +{ + char *dummy_name; + int t; + int ret = 1; + + dummy_name = make_temp_file (NULL); + for (t = 0; bfd_target_vector[t]; t++) + { + const bfd_target *p = bfd_target_vector[t]; + bfd *abfd = bfd_openw (dummy_name, p->name); + int a; + + printf ("%s\n (header %s, data %s)\n", p->name, + endian_string (p->header_byteorder), + endian_string (p->byteorder)); + + if (abfd == NULL) + { + bfd_nonfatal (dummy_name); + ret = 0; + continue; + } + + if (! bfd_set_format (abfd, bfd_object)) + { + if (bfd_get_error () != bfd_error_invalid_operation) + { + bfd_nonfatal (p->name); + ret = 0; + } + bfd_close_all_done (abfd); + continue; + } + + for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++) + if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0)) + printf (" %s\n", + bfd_printable_arch_mach ((enum bfd_architecture) a, 0)); + bfd_close_all_done (abfd); + } + unlink (dummy_name); + free (dummy_name); + + return ret; +} + +/* Print a table showing which architectures are supported for entries + FIRST through LAST-1 of bfd_target_vector (targets across, + architectures down). */ + +static int +display_info_table (int first, int last) +{ + int t; + int a; + int ret = 1; + char *dummy_name; + + /* Print heading of target names. */ + printf ("\n%*s", (int) LONGEST_ARCH, " "); + for (t = first; t < last && bfd_target_vector[t]; t++) + printf ("%s ", bfd_target_vector[t]->name); + putchar ('\n'); + + dummy_name = make_temp_file (NULL); + for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++) + if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0) + { + printf ("%*s ", (int) LONGEST_ARCH - 1, + bfd_printable_arch_mach (a, 0)); + for (t = first; t < last && bfd_target_vector[t]; t++) + { + const bfd_target *p = bfd_target_vector[t]; + bfd_boolean ok = TRUE; + bfd *abfd = bfd_openw (dummy_name, p->name); + + if (abfd == NULL) + { + bfd_nonfatal (p->name); + ret = 0; + ok = FALSE; + } + + if (ok) + { + if (! bfd_set_format (abfd, bfd_object)) + { + if (bfd_get_error () != bfd_error_invalid_operation) + { + bfd_nonfatal (p->name); + ret = 0; + } + ok = FALSE; + } + } + + if (ok) + { + if (! bfd_set_arch_mach (abfd, a, 0)) + ok = FALSE; + } + + if (ok) + printf ("%s ", p->name); + else + { + int l = strlen (p->name); + while (l--) + putchar ('-'); + putchar (' '); + } + if (abfd != NULL) + bfd_close_all_done (abfd); + } + putchar ('\n'); + } + unlink (dummy_name); + free (dummy_name); + + return ret; +} + +/* Print tables of all the target-architecture combinations that + BFD has been configured to support. */ + +static int +display_target_tables (void) +{ + int t; + int columns; + int ret = 1; + char *colum; + + columns = 0; + colum = getenv ("COLUMNS"); + if (colum != NULL) + columns = atoi (colum); + if (columns == 0) + columns = 80; + + t = 0; + while (bfd_target_vector[t] != NULL) + { + int oldt = t, wid; + + wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1; + ++t; + while (wid < columns && bfd_target_vector[t] != NULL) + { + int newwid; + + newwid = wid + strlen (bfd_target_vector[t]->name) + 1; + if (newwid >= columns) + break; + wid = newwid; + ++t; + } + if (! display_info_table (oldt, t)) + ret = 0; + } + + return ret; +} + +int +display_info (void) +{ + printf (_("BFD header file version %s\n"), BFD_VERSION_STRING); + if (! display_target_list () || ! display_target_tables ()) + return 1; + else + return 0; +} + /* 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 (file, abfd, verbose) - FILE *file; - bfd *abfd; - boolean verbose; +print_arelt_descr (FILE *file, bfd *abfd, bfd_boolean verbose) { struct stat buf; @@ -170,7 +368,7 @@ print_arelt_descr (file, abfd, verbose) char modebuf[11]; char timebuf[40]; time_t when = buf.st_mtime; - CONST char *ctime_result = (CONST char *) ctime (&when); + const char *ctime_result = (const char *) ctime (&when); /* POSIX format: skip weekday and seconds from ctime output. */ sprintf (timebuf, "%.12s %.4s", ctime_result + 4, ctime_result + 20); @@ -190,16 +388,21 @@ print_arelt_descr (file, abfd, verbose) /* Return the name of a temporary file in the same directory as FILENAME. */ char * -make_tempname (filename) - char *filename; +make_tempname (char *filename) { static char template[] = "stXXXXXX"; char *tmpname; char *slash = strrchr (filename, '/'); -#if defined (__DJGPP__) || defined (__GO32__) || defined (_WIN32) - if (slash == NULL) - slash = strrchr (filename, '\\'); +#ifdef HAVE_DOS_BASED_FILE_SYSTEM + { + /* We could have foo/bar\\baz, or foo\\bar, or d:bar. */ + char *bslash = strrchr (filename, '\\'); + if (slash == NULL || (bslash != NULL && bslash > slash)) + slash = bslash; + if (slash == NULL && filename[0] != '\0' && filename[1] == ':') + slash = filename + 1; + } #endif if (slash != (char *) NULL) @@ -208,8 +411,15 @@ make_tempname (filename) c = *slash; *slash = 0; - tmpname = xmalloc (strlen (filename) + sizeof (template) + 1); + tmpname = xmalloc (strlen (filename) + sizeof (template) + 2); strcpy (tmpname, filename); +#ifdef HAVE_DOS_BASED_FILE_SYSTEM + /* If tmpname is "X:", appending a slash will make it a root + directory on drive X, which is NOT the same as the current + directory on drive X. */ + if (tmpname[1] == ':' && tmpname[2] == '\0') + strcat (tmpname, "."); +#endif strcat (tmpname, "/"); strcat (tmpname, template); mktemp (tmpname); @@ -228,18 +438,40 @@ make_tempname (filename) parsed. */ bfd_vma -parse_vma (s, arg) - const char *s; - const char *arg; +parse_vma (const char *s, const char *arg) { bfd_vma ret; const char *end; ret = bfd_scan_vma (s, &end, 0); + if (*end != '\0') - { - fprintf (stderr, "%s: %s: bad number: %s\n", program_name, arg, s); - exit (1); - } + fatal (_("%s: bad number: %s"), arg, s); + return ret; } + +/* Returns the size of the named file. If the file does not + exist, or if it is not a real file, then a suitable non-fatal + error message is printed and zero is returned. */ + +off_t +get_file_size (const char * file_name) +{ + struct stat statbuf; + + if (stat (file_name, &statbuf) < 0) + { + if (errno == ENOENT) + non_fatal (_("'%s': No such file"), file_name); + else + non_fatal (_("Warning: could not locate '%s'. reason: %s"), + file_name, strerror (errno)); + } + else if (! S_ISREG (statbuf.st_mode)) + non_fatal (_("Warning: '%s' is not an ordinary file"), file_name); + else + return statbuf.st_size; + + return 0; +}