binutils/bucomm.c

   1 /* bucomm.c -- Bin Utils COMmon code.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1997, 1998, 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21 \f
  22 /* We might put this in a library someday so it could be dynamically
  23    loaded, but for now it's not necessary.  */
  24
  25 #include "bfd.h"
  26 #include "bfdver.h"
  27 #include "libiberty.h"
  28 #include "bucomm.h"
  29 #include "filenames.h"
  30 #include "libbfd.h"
  31
  32 #include <sys/stat.h>
  33 #include <time.h>               /* ctime, maybe time_t */
  34
  35 #ifndef HAVE_TIME_T_IN_TIME_H
  36 #ifndef HAVE_TIME_T_IN_TYPES_H
  37 typedef long time_t;
  38 #endif
  39 #endif
  40
  41 static const char * endian_string (enum bfd_endian);
  42 static int display_target_list (void);
  43 static int display_info_table (int, int);
  44 static int display_target_tables (void);
  45 \f
  46 /* Error reporting.  */
  47
  48 char *program_name;
  49
  50 void
  51 bfd_nonfatal (const char *string)
  52 {
  53   const char *errmsg = bfd_errmsg (bfd_get_error ());
  54
  55   if (string)
  56     fprintf (stderr, "%s: %s: %s\n", program_name, string, errmsg);
  57   else
  58     fprintf (stderr, "%s: %s\n", program_name, errmsg);
  59 }
  60
  61 void
  62 bfd_fatal (const char *string)
  63 {
  64   bfd_nonfatal (string);
  65   xexit (1);
  66 }
  67
  68 static void
  69 report (const char * format, va_list args)
  70 {
  71   fprintf (stderr, "%s: ", program_name);
  72   vfprintf (stderr, format, args);
  73   putc ('\n', stderr);
  74 }
  75
  76 void
  77 fatal VPARAMS ((const char *format, ...))
  78 {
  79   VA_OPEN (args, format);
  80   VA_FIXEDARG (args, const char *, format);
  81
  82   report (format, args);
  83   VA_CLOSE (args);
  84   xexit (1);
  85 }
  86
  87 void
  88 non_fatal VPARAMS ((const char *format, ...))
  89 {
  90   VA_OPEN (args, format);
  91   VA_FIXEDARG (args, const char *, format);
  92
  93   report (format, args);
  94   VA_CLOSE (args);
  95 }
  96
  97 /* Set the default BFD target based on the configured target.  Doing
  98    this permits the binutils to be configured for a particular target,
  99    and linked against a shared BFD library which was configured for a
 100    different target.  */
 101
 102 void
 103 set_default_bfd_target (void)
 104 {
 105   /* The macro TARGET is defined by Makefile.  */
 106   const char *target = TARGET;
 107
 108   if (! bfd_set_default_target (target))
 109     fatal (_("can't set BFD default target to `%s': %s"),
 110            target, bfd_errmsg (bfd_get_error ()));
 111 }
 112
 113 /* After a FALSE return from bfd_check_format_matches with
 114    bfd_get_error () == bfd_error_file_ambiguously_recognized, print
 115    the possible matching targets.  */
 116
 117 void
 118 list_matching_formats (char **p)
 119 {
 120   fprintf (stderr, _("%s: Matching formats:"), program_name);
 121   while (*p)
 122     fprintf (stderr, " %s", *p++);
 123   fputc ('\n', stderr);
 124 }
 125
 126 /* List the supported targets.  */
 127
 128 void
 129 list_supported_targets (const char *name, FILE *f)
 130 {
 131   int t;
 132   const char **targ_names = bfd_target_list ();
 133
 134   if (name == NULL)
 135     fprintf (f, _("Supported targets:"));
 136   else
 137     fprintf (f, _("%s: supported targets:"), name);
 138
 139   for (t = 0; targ_names[t] != NULL; t++)
 140     fprintf (f, " %s", targ_names[t]);
 141   fprintf (f, "\n");
 142   free (targ_names);
 143 }
 144
 145 /* List the supported architectures.  */
 146
 147 void
 148 list_supported_architectures (const char *name, FILE *f)
 149 {
 150   const char **arch;
 151
 152   if (name == NULL)
 153     fprintf (f, _("Supported architectures:"));
 154   else
 155     fprintf (f, _("%s: supported architectures:"), name);
 156
 157   for (arch = bfd_arch_list (); *arch; arch++)
 158     fprintf (f, " %s", *arch);
 159   fprintf (f, "\n");
 160 }
 161 \f
 162 /* The length of the longest architecture name + 1.  */
 163 #define LONGEST_ARCH sizeof ("powerpc:common")
 164
 165 static const char *
 166 endian_string (enum bfd_endian endian)
 167 {
 168   switch (endian)
 169     {
 170     case BFD_ENDIAN_BIG: return "big endian";
 171     case BFD_ENDIAN_LITTLE: return "little endian";
 172     default: return "endianness unknown";
 173     }
 174 }
 175
 176 /* List the targets that BFD is configured to support, each followed
 177    by its endianness and the architectures it supports.  */
 178
 179 static int
 180 display_target_list (void)
 181 {
 182   char *dummy_name;
 183   int t;
 184   int ret = 1;
 185
 186   dummy_name = make_temp_file (NULL);
 187   for (t = 0; bfd_target_vector[t]; t++)
 188     {
 189       const bfd_target *p = bfd_target_vector[t];
 190       bfd *abfd = bfd_openw (dummy_name, p->name);
 191       int a;
 192
 193       printf ("%s\n (header %s, data %s)\n", p->name,
 194               endian_string (p->header_byteorder),
 195               endian_string (p->byteorder));
 196
 197       if (abfd == NULL)
 198         {
 199           bfd_nonfatal (dummy_name);
 200           ret = 0;
 201           continue;
 202         }
 203
 204       if (! bfd_set_format (abfd, bfd_object))
 205         {
 206           if (bfd_get_error () != bfd_error_invalid_operation)
 207             {
 208               bfd_nonfatal (p->name);
 209               ret = 0;
 210             }
 211           bfd_close_all_done (abfd);
 212           continue;
 213         }
 214
 215       for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
 216         if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
 217           printf ("  %s\n",
 218                   bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
 219       bfd_close_all_done (abfd);
 220     }
 221   unlink (dummy_name);
 222   free (dummy_name);
 223
 224   return ret;
 225 }
 226
 227 /* Print a table showing which architectures are supported for entries
 228    FIRST through LAST-1 of bfd_target_vector (targets across,
 229    architectures down).  */
 230
 231 static int
 232 display_info_table (int first, int last)
 233 {
 234   int t;
 235   int a;
 236   int ret = 1;
 237   char *dummy_name;
 238
 239   /* Print heading of target names.  */
 240   printf ("\n%*s", (int) LONGEST_ARCH, " ");
 241   for (t = first; t < last && bfd_target_vector[t]; t++)
 242     printf ("%s ", bfd_target_vector[t]->name);
 243   putchar ('\n');
 244
 245   dummy_name = make_temp_file (NULL);
 246   for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
 247     if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
 248       {
 249         printf ("%*s ", (int) LONGEST_ARCH - 1,
 250                 bfd_printable_arch_mach (a, 0));
 251         for (t = first; t < last && bfd_target_vector[t]; t++)
 252           {
 253             const bfd_target *p = bfd_target_vector[t];
 254             bfd_boolean ok = TRUE;
 255             bfd *abfd = bfd_openw (dummy_name, p->name);
 256
 257             if (abfd == NULL)
 258               {
 259                 bfd_nonfatal (p->name);
 260                 ret = 0;
 261                 ok = FALSE;
 262               }
 263
 264             if (ok)
 265               {
 266                 if (! bfd_set_format (abfd, bfd_object))
 267                   {
 268                     if (bfd_get_error () != bfd_error_invalid_operation)
 269                       {
 270                         bfd_nonfatal (p->name);
 271                         ret = 0;
 272                       }
 273                     ok = FALSE;
 274                   }
 275               }
 276
 277             if (ok)
 278               {
 279                 if (! bfd_set_arch_mach (abfd, a, 0))
 280                   ok = FALSE;
 281               }
 282
 283             if (ok)
 284               printf ("%s ", p->name);
 285             else
 286               {
 287                 int l = strlen (p->name);
 288                 while (l--)
 289                   putchar ('-');
 290                 putchar (' ');
 291               }
 292             if (abfd != NULL)
 293               bfd_close_all_done (abfd);
 294           }
 295         putchar ('\n');
 296       }
 297   unlink (dummy_name);
 298   free (dummy_name);
 299
 300   return ret;
 301 }
 302
 303 /* Print tables of all the target-architecture combinations that
 304    BFD has been configured to support.  */
 305
 306 static int
 307 display_target_tables (void)
 308 {
 309   int t;
 310   int columns;
 311   int ret = 1;
 312   char *colum;
 313
 314   columns = 0;
 315   colum = getenv ("COLUMNS");
 316   if (colum != NULL)
 317     columns = atoi (colum);
 318   if (columns == 0)
 319     columns = 80;
 320
 321   t = 0;
 322   while (bfd_target_vector[t] != NULL)
 323     {
 324       int oldt = t, wid;
 325
 326       wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
 327       ++t;
 328       while (wid < columns && bfd_target_vector[t] != NULL)
 329         {
 330           int newwid;
 331
 332           newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
 333           if (newwid >= columns)
 334             break;
 335           wid = newwid;
 336           ++t;
 337         }
 338       if (! display_info_table (oldt, t))
 339         ret = 0;
 340     }
 341
 342   return ret;
 343 }
 344
 345 int
 346 display_info (void)
 347 {
 348   printf (_("BFD header file version %s\n"), BFD_VERSION_STRING);
 349   if (! display_target_list () || ! display_target_tables ())
 350     return 1;
 351   else
 352     return 0;
 353 }
 354 \f
 355 /* Display the archive header for an element as if it were an ls -l listing:
 356
 357    Mode       User\tGroup\tSize\tDate               Name */
 358
 359 void
 360 print_arelt_descr (FILE *file, bfd *abfd, bfd_boolean verbose)
 361 {
 362   struct stat buf;
 363
 364   if (verbose)
 365     {
 366       if (bfd_stat_arch_elt (abfd, &buf) == 0)
 367         {
 368           char modebuf[11];
 369           char timebuf[40];
 370           time_t when = buf.st_mtime;
 371           const char *ctime_result = (const char *) ctime (&when);
 372
 373           /* POSIX format:  skip weekday and seconds from ctime output.  */
 374           sprintf (timebuf, "%.12s %.4s", ctime_result + 4, ctime_result + 20);
 375
 376           mode_string (buf.st_mode, modebuf);
 377           modebuf[10] = '\0';
 378           /* POSIX 1003.2/D11 says to skip first character (entry type).  */
 379           fprintf (file, "%s %ld/%ld %6ld %s ", modebuf + 1,
 380                    (long) buf.st_uid, (long) buf.st_gid,
 381                    (long) buf.st_size, timebuf);
 382         }
 383     }
 384
 385   fprintf (file, "%s\n", bfd_get_filename (abfd));
 386 }
 387
 388 /* Return the name of a temporary file in the same directory as FILENAME.  */
 389
 390 char *
 391 make_tempname (char *filename)
 392 {
 393   static char template[] = "stXXXXXX";
 394   char *tmpname;
 395   char *slash = strrchr (filename, '/');
 396
 397 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 398   {
 399     /* We could have foo/bar\\baz, or foo\\bar, or d:bar.  */
 400     char *bslash = strrchr (filename, '\\');
 401     if (slash == NULL || (bslash != NULL && bslash > slash))
 402       slash = bslash;
 403     if (slash == NULL && filename[0] != '\0' && filename[1] == ':')
 404       slash = filename + 1;
 405   }
 406 #endif
 407
 408   if (slash != (char *) NULL)
 409     {
 410       char c;
 411
 412       c = *slash;
 413       *slash = 0;
 414       tmpname = xmalloc (strlen (filename) + sizeof (template) + 2);
 415       strcpy (tmpname, filename);
 416 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 417       /* If tmpname is "X:", appending a slash will make it a root
 418          directory on drive X, which is NOT the same as the current
 419          directory on drive X.  */
 420       if (tmpname[1] == ':' && tmpname[2] == '\0')
 421         strcat (tmpname, ".");
 422 #endif
 423       strcat (tmpname, "/");
 424       strcat (tmpname, template);
 425       mktemp (tmpname);
 426       *slash = c;
 427     }
 428   else
 429     {
 430       tmpname = xmalloc (sizeof (template));
 431       strcpy (tmpname, template);
 432       mktemp (tmpname);
 433     }
 434   return tmpname;
 435 }
 436
 437 /* Parse a string into a VMA, with a fatal error if it can't be
 438    parsed.  */
 439
 440 bfd_vma
 441 parse_vma (const char *s, const char *arg)
 442 {
 443   bfd_vma ret;
 444   const char *end;
 445
 446   ret = bfd_scan_vma (s, &end, 0);
 447
 448   if (*end != '\0')
 449     fatal (_("%s: bad number: %s"), arg, s);
 450
 451   return ret;
 452 }
 453
 454 /* Returns the size of the named file.  If the file does not
 455    exist, or if it is not a real file, then a suitable non-fatal
 456    error message is printed and zero is returned.  */
 457
 458 off_t
 459 get_file_size (const char * file_name)
 460 {
 461   struct stat statbuf;
 462
 463   if (stat (file_name, &statbuf) < 0)
 464     {
 465       if (errno == ENOENT)
 466         non_fatal (_("'%s': No such file"), file_name);
 467       else
 468         non_fatal (_("Warning: could not locate '%s'.  reason: %s"),
 469                    file_name, strerror (errno));
 470     }
 471   else if (! S_ISREG (statbuf.st_mode))
 472     non_fatal (_("Warning: '%s' is not an ordinary file"), file_name);
 473   else
 474     return statbuf.st_size;
 475
 476   return 0;
 477 }