binutils/bucomm.c

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