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