OSDN Git Service

bfd/
[pf3gnuchains/pf3gnuchains4x.git] / 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 }