gdb: add target_ops::supports_displaced_step

[deliverable/binutils-gdb.git] / binutils / bucomm.c

diff --git a/binutils/bucomm.c b/binutils/bucomm.c
index cfc7d4e4e2991b4518e455a88fb578ac59ca6384..9e6a02843e6c7ba11545f69a6a31e927d177a9b0 100644 (file)
--- a/binutils/bucomm.c
+++ b/binutils/bucomm.c
@@ -1,13 +1,11 @@
 /* bucomm.c -- Bin Utils COMmon code.
 /* bucomm.c -- Bin Utils COMmon code.

-   Copyright 1991, 1992, 1993, 1994, 1995, 1997, 1998, 2000, 2001, 2002,
-   2003, 2006
-   Free Software Foundation, Inc.
+   Copyright (C) 1991-2020 Free Software Foundation, Inc.

 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -23,27 +21,20 @@
 /* We might put this in a library someday so it could be dynamically
    loaded, but for now it's not necessary.  */
 
 /* We might put this in a library someday so it could be dynamically
    loaded, but for now it's not necessary.  */
 

+#include "sysdep.h"

 #include "bfd.h"
 #include "bfd.h"

-#include "bfdver.h"

 #include "libiberty.h"
 #include "libiberty.h"

-#include "bucomm.h"

 #include "filenames.h"
 #include "filenames.h"

-#include "libbfd.h"

 
 

-#include <sys/stat.h>

 #include <time.h>              /* ctime, maybe time_t */
 #include <assert.h>
 #include <time.h>              /* ctime, maybe time_t */
 #include <assert.h>

+#include "bucomm.h"

 
 #ifndef HAVE_TIME_T_IN_TIME_H
 #ifndef HAVE_TIME_T_IN_TYPES_H
 typedef long time_t;
 #endif
 #endif
 
 #ifndef HAVE_TIME_T_IN_TIME_H
 #ifndef HAVE_TIME_T_IN_TYPES_H
 typedef long time_t;
 #endif
 #endif

-
-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);

 \f
 /* Error reporting.  */
 
 \f
 /* Error reporting.  */
 


@@ -52,14 +43,73 @@ char *program_name;
 void
 bfd_nonfatal (const char *string)
 {
 void
 bfd_nonfatal (const char *string)
 {

-  const char *errmsg = bfd_errmsg (bfd_get_error ());
+  const char *errmsg;
+  enum bfd_error err = bfd_get_error ();

 
 

+  if (err == bfd_error_no_error)
+    errmsg = _("cause of error unknown");
+  else
+    errmsg = bfd_errmsg (err);
+  fflush (stdout);

   if (string)
     fprintf (stderr, "%s: %s: %s\n", program_name, string, errmsg);
   else
     fprintf (stderr, "%s: %s\n", program_name, errmsg);
 }
 
   if (string)
     fprintf (stderr, "%s: %s: %s\n", program_name, string, errmsg);
   else
     fprintf (stderr, "%s: %s\n", program_name, errmsg);
 }
 

+/* Issue a non fatal error message.  FILENAME, or if NULL then BFD,
+   are used to indicate the problematic file.  SECTION, if non NULL,
+   is used to provide a section name.  If FORMAT is non-null, then it
+   is used to print additional information via vfprintf.  Finally the
+   bfd error message is printed.  In summary, error messages are of
+   one of the following forms:
+
+   PROGRAM: file: bfd-error-message
+   PROGRAM: file[section]: bfd-error-message
+   PROGRAM: file: printf-message: bfd-error-message
+   PROGRAM: file[section]: printf-message: bfd-error-message.  */
+
+void
+bfd_nonfatal_message (const char *filename,
+                     const bfd *abfd,
+                     const asection *section,
+                     const char *format, ...)
+{
+  const char *errmsg;
+  const char *section_name;
+  va_list args;
+  enum bfd_error err = bfd_get_error ();
+
+  if (err == bfd_error_no_error)
+    errmsg = _("cause of error unknown");
+  else
+    errmsg = bfd_errmsg (err);
+  fflush (stdout);
+  section_name = NULL;
+  va_start (args, format);
+  fprintf (stderr, "%s", program_name);
+
+  if (abfd)
+    {
+      if (!filename)
+       filename = bfd_get_archive_filename (abfd);
+      if (section)
+       section_name = bfd_section_name (section);
+    }
+  if (section_name)
+    fprintf (stderr, ": %s[%s]", filename, section_name);
+  else
+    fprintf (stderr, ": %s", filename);
+
+  if (format)
+    {
+      fprintf (stderr, ": ");
+      vfprintf (stderr, format, args);
+    }
+  fprintf (stderr, ": %s\n", errmsg);
+  va_end (args);
+}
+

 void
 bfd_fatal (const char *string)
 {
 void
 bfd_fatal (const char *string)
 {


@@ -70,30 +120,33 @@ bfd_fatal (const char *string)
 void
 report (const char * format, va_list args)
 {
 void
 report (const char * format, va_list args)
 {

+  fflush (stdout);

   fprintf (stderr, "%s: ", program_name);
   vfprintf (stderr, format, args);
   putc ('\n', stderr);
 }
 
 void
   fprintf (stderr, "%s: ", program_name);
   vfprintf (stderr, format, args);
   putc ('\n', stderr);
 }
 
 void

-fatal VPARAMS ((const char *format, ...))
+fatal (const char *format, ...)

 {
 {

-  VA_OPEN (args, format);
-  VA_FIXEDARG (args, const char *, format);
+  va_list args;
+
+  va_start (args, format);

 
   report (format, args);
 
   report (format, args);

-  VA_CLOSE (args);
+  va_end (args);

   xexit (1);
 }
 
 void
   xexit (1);
 }
 
 void

-non_fatal VPARAMS ((const char *format, ...))
+non_fatal (const char *format, ...)

 {
 {

-  VA_OPEN (args, format);
-  VA_FIXEDARG (args, const char *, format);
+  va_list args;
+
+  va_start (args, format);

 
   report (format, args);
 
   report (format, args);

-  VA_CLOSE (args);
+  va_end (args);

 }
 
 /* Set the default BFD target based on the configured target.  Doing
 }
 
 /* Set the default BFD target based on the configured target.  Doing


@@ -119,6 +172,7 @@ set_default_bfd_target (void)
 void
 list_matching_formats (char **p)
 {
 void
 list_matching_formats (char **p)
 {

+  fflush (stdout);

   fprintf (stderr, _("%s: Matching formats:"), program_name);
   while (*p)
     fprintf (stderr, " %s", *p++);
   fprintf (stderr, _("%s: Matching formats:"), program_name);
   while (*p)
     fprintf (stderr, " %s", *p++);


@@ -131,13 +185,14 @@ void
 list_supported_targets (const char *name, FILE *f)
 {
   int t;
 list_supported_targets (const char *name, FILE *f)
 {
   int t;

-  const char **targ_names = bfd_target_list ();
+  const char **targ_names;

 
   if (name == NULL)
     fprintf (f, _("Supported targets:"));
   else
     fprintf (f, _("%s: supported targets:"), name);
 
 
   if (name == NULL)
     fprintf (f, _("Supported targets:"));
   else
     fprintf (f, _("%s: supported targets:"), name);
 

+  targ_names = bfd_target_list ();

   for (t = 0; targ_names[t] != NULL; t++)
     fprintf (f, " %s", targ_names[t]);
   fprintf (f, "\n");
   for (t = 0; targ_names[t] != NULL; t++)
     fprintf (f, " %s", targ_names[t]);
   fprintf (f, "\n");


@@ -149,209 +204,230 @@ list_supported_targets (const char *name, FILE *f)
 void
 list_supported_architectures (const char *name, FILE *f)
 {
 void
 list_supported_architectures (const char *name, FILE *f)
 {

-  const char **arch;
+  const char ** arch;
+  const char ** arches;

 
   if (name == NULL)
     fprintf (f, _("Supported architectures:"));
   else
     fprintf (f, _("%s: supported architectures:"), name);
 
 
   if (name == NULL)
     fprintf (f, _("Supported architectures:"));
   else
     fprintf (f, _("%s: supported architectures:"), name);
 

-  for (arch = bfd_arch_list (); *arch; arch++)
+  for (arch = arches = bfd_arch_list (); *arch; arch++)

     fprintf (f, " %s", *arch);
   fprintf (f, "\n");
     fprintf (f, " %s", *arch);
   fprintf (f, "\n");

+  free (arches);

 }
 \f
 }
 \f

-/* 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)
     {
 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";
+    case BFD_ENDIAN_BIG: return _("big endian");
+    case BFD_ENDIAN_LITTLE: return _("little endian");
+    default: return _("endianness unknown");

     }
 }
 
     }
 }
 

+/* Data passed to do_display_target and other target iterators.  */
+
+struct display_target {
+  /* Temp file.  */
+  char *filename;
+  /* Return status.  */
+  int error;
+  /* Number of targets.  */
+  int count;
+  /* Size of info in bytes.  */
+  size_t alloc;
+  /* Per-target info.  */
+  struct {
+    /* Target name.  */
+    const char *name;
+    /* Non-zero if target/arch combination supported.  */
+    unsigned char arch[bfd_arch_last - bfd_arch_obscure - 1];
+  } *info;
+};
+

 /* List the targets that BFD is configured to support, each followed
 /* List the targets that BFD is configured to support, each followed

-   by its endianness and the architectures it supports.  */
+   by its endianness and the architectures it supports.  Also build
+   info about target/archs.  */

 
 static int
 
 static int

-display_target_list (void)
+do_display_target (const bfd_target *targ, void *data)

 {
 {

-  char *dummy_name;
-  int t;
-  int ret = 1;
+  struct display_target *param = (struct display_target *) data;
+  bfd *abfd;
+  size_t amt;

 
 

-  dummy_name = make_temp_file (NULL);
-  for (t = 0; bfd_target_vector[t]; t++)
+  param->count += 1;
+  amt = param->count * sizeof (*param->info);
+  if (param->alloc < amt)

     {
     {

-      const bfd_target *p = bfd_target_vector[t];
-      bfd *abfd = bfd_openw (dummy_name, p->name);
-      enum bfd_architecture a;
-
-      printf ("%s\n (header %s, data %s)\n", p->name,
-             endian_string (p->header_byteorder),
-             endian_string (p->byteorder));
+      size_t size = ((param->count < 64 ? 64 : param->count)
+                    * sizeof (*param->info) * 2);
+      param->info = xrealloc (param->info, size);
+      memset ((char *) param->info + param->alloc, 0, size - param->alloc);
+      param->alloc = size;
+    }
+  param->info[param->count - 1].name = targ->name;

 
 

-      if (abfd == NULL)
-       {
-          bfd_nonfatal (dummy_name);
-          ret = 0;
-         continue;
-       }
+  printf (_("%s\n (header %s, data %s)\n"), targ->name,
+         endian_string (targ->header_byteorder),
+         endian_string (targ->byteorder));

 
 

-      if (! bfd_set_format (abfd, bfd_object))
+  abfd = bfd_openw (param->filename, targ->name);
+  if (abfd == NULL)
+    {
+      bfd_nonfatal (param->filename);
+      param->error = 1;
+    }
+  else if (!bfd_set_format (abfd, bfd_object))
+    {
+      if (bfd_get_error () != bfd_error_invalid_operation)

        {
        {

-         if (bfd_get_error () != bfd_error_invalid_operation)
-            {
-             bfd_nonfatal (p->name);
-              ret = 0;
-            }
-         bfd_close_all_done (abfd);
-         continue;
+         bfd_nonfatal (targ->name);
+         param->error = 1;

        }
        }

+    }
+  else
+    {
+      enum bfd_architecture a;

 
       for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
 
       for (a = bfd_arch_obscure + 1; a < 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);
+       if (bfd_set_arch_mach (abfd, a, 0))
+         {
+           printf ("  %s\n", bfd_printable_arch_mach (a, 0));
+           param->info[param->count - 1].arch[a - bfd_arch_obscure - 1] = 1;
+         }

     }
     }

-  unlink (dummy_name);
-  free (dummy_name);
+  if (abfd != NULL)
+    bfd_close_all_done (abfd);

 
 

-  return ret;
+  return param->error;
+}
+
+static void
+display_target_list (struct display_target *arg)
+{
+  arg->filename = make_temp_file (NULL);
+  arg->error = 0;
+  arg->count = 0;
+  arg->alloc = 0;
+  arg->info = NULL;
+
+  bfd_iterate_over_targets (do_display_target, arg);
+
+  unlink (arg->filename);
+  free (arg->filename);

 }
 
 }
 

-/* Print a table showing which architectures are supported for entries
-   FIRST through LAST-1 of bfd_target_vector (targets across,
-   architectures down).  */
+/* Calculate how many targets we can print across the page.  */

 
 static int
 
 static int

-display_info_table (int first, int last)
+do_info_size (int targ, int width, const struct display_target *arg)

 {
 {

-  int t;
-  int ret = 1;
-  char *dummy_name;
-  enum bfd_architecture a;
-
-  /* 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 = bfd_arch_obscure + 1; a < 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);
+  while (targ < arg->count)
+    {
+      width -= strlen (arg->info[targ].name) + 1;
+      if (width < 0)
+       return targ;
+      ++targ;
+    }
+  return targ;
+}

 
 

-  return ret;
+/* Print header of target names.  */
+
+static void
+do_info_header (int targ, int stop_targ, const struct display_target *arg)
+{
+  while (targ != stop_targ)
+    printf ("%s ", arg->info[targ++].name);
+}
+
+/* Print a table row.  */
+
+static void
+do_info_row (int targ, int stop_targ, enum bfd_architecture a,
+            const struct display_target *arg)
+{
+  while (targ != stop_targ)
+    {
+      if (arg->info[targ].arch[a - bfd_arch_obscure - 1])
+       fputs (arg->info[targ].name, stdout);
+      else
+       {
+         int l = strlen (arg->info[targ].name);
+         while (l--)
+           putchar ('-');
+       }
+      ++targ;
+      if (targ != stop_targ)
+       putchar (' ');
+    }

 }
 
 /* Print tables of all the target-architecture combinations that
    BFD has been configured to support.  */
 
 }
 
 /* Print tables of all the target-architecture combinations that
    BFD has been configured to support.  */
 

-static int
-display_target_tables (void)
+static void
+display_target_tables (const struct display_target *arg)

 {
 {

-  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)
+  const char *columns;
+  int width, start_targ, stop_targ;
+  enum bfd_architecture arch;
+  int longest_arch = 0;
+
+  for (arch = bfd_arch_obscure + 1; arch < bfd_arch_last; arch++)

     {
     {

-      int oldt = t, wid;
+      const char *s = bfd_printable_arch_mach (arch, 0);
+      int len = strlen (s);
+      if (len > longest_arch)
+       longest_arch = len;
+    }

 
 

-      wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
-      ++t;
-      while (wid < columns && bfd_target_vector[t] != NULL)
-       {
-         int newwid;
+  width = 0;
+  columns = getenv ("COLUMNS");
+  if (columns != NULL)
+    width = atoi (columns);
+  if (width == 0)
+    width = 80;
+
+  for (start_targ = 0; start_targ < arg->count; start_targ = stop_targ)
+    {
+      stop_targ = do_info_size (start_targ, width - longest_arch - 1, arg);

 
 

-         newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
-         if (newwid >= columns)
-           break;
-         wid = newwid;
-         ++t;
+      printf ("\n%*s", longest_arch + 1, " ");
+      do_info_header (start_targ, stop_targ, arg);
+      putchar ('\n');
+
+      for (arch = bfd_arch_obscure + 1; arch < bfd_arch_last; arch++)
+       {
+         if (strcmp (bfd_printable_arch_mach (arch, 0), "UNKNOWN!") != 0)
+           {
+             printf ("%*s ", longest_arch,
+                     bfd_printable_arch_mach (arch, 0));
+
+             do_info_row (start_targ, stop_targ, arch, arg);
+             putchar ('\n');
+           }

        }
        }

-      if (! display_info_table (oldt, t))
-        ret = 0;

     }
     }

-
-  return ret;

 }
 
 int
 display_info (void)
 {
 }
 
 int
 display_info (void)
 {

+  struct display_target arg;
+

   printf (_("BFD header file version %s\n"), BFD_VERSION_STRING);
   printf (_("BFD header file version %s\n"), BFD_VERSION_STRING);

-  if (! display_target_list () || ! display_target_tables ())
-    return 1;
-  else
-    return 0;
+
+  display_target_list (&arg);
+  if (!arg.error)
+    display_target_tables (&arg);
+
+  return arg.error;

 }
 \f
 /* Display the archive header for an element as if it were an ls -l listing:
 }
 \f
 /* Display the archive header for an element as if it were an ls -l listing:


@@ -359,7 +435,7 @@ display_info (void)
    Mode       User\tGroup\tSize\tDate               Name */
 
 void
    Mode       User\tGroup\tSize\tDate               Name */
 
 void

-print_arelt_descr (FILE *file, bfd *abfd, bfd_boolean verbose)
+print_arelt_descr (FILE *file, bfd *abfd, bfd_boolean verbose, bfd_boolean offsets)

 {
   struct stat buf;
 
 {
   struct stat buf;
 


@@ -371,20 +447,36 @@ print_arelt_descr (FILE *file, bfd *abfd, bfd_boolean verbose)
          char timebuf[40];
          time_t when = buf.st_mtime;
          const char *ctime_result = (const char *) ctime (&when);
          char timebuf[40];
          time_t when = buf.st_mtime;
          const char *ctime_result = (const char *) ctime (&when);

+         bfd_size_type size;

 
 

-         /* POSIX format:  skip weekday and seconds from ctime output.  */
-         sprintf (timebuf, "%.12s %.4s", ctime_result + 4, ctime_result + 20);
+         /* PR binutils/17605: Check for corrupt time values.  */
+         if (ctime_result == NULL)
+           sprintf (timebuf, _("<time data corrupt>"));
+         else
+           /* POSIX format:  skip weekday and seconds from ctime output.  */
+           sprintf (timebuf, "%.12s %.4s", ctime_result + 4, ctime_result + 20);

 
          mode_string (buf.st_mode, modebuf);
          modebuf[10] = '\0';
 
          mode_string (buf.st_mode, modebuf);
          modebuf[10] = '\0';

+         size = buf.st_size;

          /* POSIX 1003.2/D11 says to skip first character (entry type).  */
          /* POSIX 1003.2/D11 says to skip first character (entry type).  */

-         fprintf (file, "%s %ld/%ld %6ld %s ", modebuf + 1,
+         fprintf (file, "%s %ld/%ld %6" BFD_VMA_FMT "u %s ", modebuf + 1,

                   (long) buf.st_uid, (long) buf.st_gid,
                   (long) buf.st_uid, (long) buf.st_gid,

-                  (long) buf.st_size, timebuf);
+                  size, timebuf);

        }
     }
 
        }
     }
 

-  fprintf (file, "%s\n", bfd_get_filename (abfd));
+  fprintf (file, "%s", bfd_get_filename (abfd));
+
+  if (offsets)
+    {
+      if (bfd_is_thin_archive (abfd) && abfd->proxy_origin)
+        fprintf (file, " 0x%lx", (unsigned long) abfd->proxy_origin);
+      else if (!bfd_is_thin_archive (abfd) && abfd->origin)
+        fprintf (file, " 0x%lx", (unsigned long) abfd->origin);
+    }
+
+  fprintf (file, "\n");

 }
 
 /* Return a path for a new temporary file in the same directory
 }
 
 /* Return a path for a new temporary file in the same directory


@@ -394,7 +486,7 @@ static char *
 template_in_dir (const char *path)
 {
 #define template "stXXXXXX"
 template_in_dir (const char *path)
 {
 #define template "stXXXXXX"

-  char *slash = strrchr (path, '/');
+  const char *slash = strrchr (path, '/');

   char *tmpname;
   size_t len;
 
   char *tmpname;
   size_t len;
 


@@ -406,14 +498,14 @@ template_in_dir (const char *path)
     if (slash == NULL || (bslash != NULL && bslash > slash))
       slash = bslash;
     if (slash == NULL && path[0] != '\0' && path[1] == ':')
     if (slash == NULL || (bslash != NULL && bslash > slash))
       slash = bslash;
     if (slash == NULL && path[0] != '\0' && path[1] == ':')

-      slash = filename + 1;
+      slash = path + 1;

   }
 #endif
 
   if (slash != (char *) NULL)
     {
       len = slash - path;
   }
 #endif
 
   if (slash != (char *) NULL)
     {
       len = slash - path;

-      tmpname = xmalloc (len + sizeof (template) + 2);
+      tmpname = (char *) xmalloc (len + sizeof (template) + 2);

       memcpy (tmpname, path, len);
 
 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
       memcpy (tmpname, path, len);
 
 #ifdef HAVE_DOS_BASED_FILE_SYSTEM


@@ -427,7 +519,7 @@ template_in_dir (const char *path)
     }
   else
     {
     }
   else
     {

-      tmpname = xmalloc (sizeof (template));
+      tmpname = (char *) xmalloc (sizeof (template));

       len = 0;
     }
 
       len = 0;
     }
 


@@ -440,7 +532,7 @@ template_in_dir (const char *path)
    as FILENAME.  */
 
 char *
    as FILENAME.  */
 
 char *

-make_tempname (char *filename)
+make_tempname (const char *filename)

 {
   char *tmpname = template_in_dir (filename);
   int fd;
 {
   char *tmpname = template_in_dir (filename);
   int fd;


@@ -454,7 +546,10 @@ make_tempname (char *filename)
   fd = open (tmpname, O_RDWR | O_CREAT | O_EXCL, 0600);
 #endif
   if (fd == -1)
   fd = open (tmpname, O_RDWR | O_CREAT | O_EXCL, 0600);
 #endif
   if (fd == -1)

-    return NULL;
+    {
+      free (tmpname);
+      return NULL;
+    }

   close (fd);
   return tmpname;
 }
   close (fd);
   return tmpname;
 }


@@ -463,7 +558,7 @@ make_tempname (char *filename)
    directory containing FILENAME.  */
 
 char *
    directory containing FILENAME.  */
 
 char *

-make_tempdir (char *filename)
+make_tempdir (const char *filename)

 {
   char *tmpname = template_in_dir (filename);
 
 {
   char *tmpname = template_in_dir (filename);
 


@@ -503,13 +598,16 @@ parse_vma (const char *s, const char *arg)
 
 /* 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
 
 /* 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.  */
+   error message is printed and (off_t) -1 is returned.  */

 
 off_t
 get_file_size (const char * file_name)
 {
   struct stat statbuf;
 
 off_t
 get_file_size (const char * file_name)
 {
   struct stat statbuf;

-  
+
+  if (file_name == NULL)
+    return (off_t) -1;
+

   if (stat (file_name, &statbuf) < 0)
     {
       if (errno == ENOENT)
   if (stat (file_name, &statbuf) < 0)
     {
       if (errno == ENOENT)


@@ -517,27 +615,33 @@ get_file_size (const char * file_name)
       else
        non_fatal (_("Warning: could not locate '%s'.  reason: %s"),
                   file_name, strerror (errno));
       else
        non_fatal (_("Warning: could not locate '%s'.  reason: %s"),
                   file_name, strerror (errno));

-    }  
+    }
+  else if (S_ISDIR (statbuf.st_mode))
+    non_fatal (_("Warning: '%s' is a directory"), file_name);

   else if (! S_ISREG (statbuf.st_mode))
     non_fatal (_("Warning: '%s' is not an ordinary file"), file_name);
   else if (! S_ISREG (statbuf.st_mode))
     non_fatal (_("Warning: '%s' is not an ordinary file"), file_name);

+  else if (statbuf.st_size < 0)
+    non_fatal (_("Warning: '%s' has negative size, probably it is too large"),
+               file_name);

   else
     return statbuf.st_size;
 
   else
     return statbuf.st_size;
 

-  return 0;
+  return (off_t) -1;

 }
 
 /* Return the filename in a static buffer.  */
 
 const char *
 }
 
 /* Return the filename in a static buffer.  */
 
 const char *

-bfd_get_archive_filename (bfd *abfd)
+bfd_get_archive_filename (const bfd *abfd)

 {
   static size_t curr = 0;
   static char *buf;
   size_t needed;
 
   assert (abfd != NULL);
 {
   static size_t curr = 0;
   static char *buf;
   size_t needed;
 
   assert (abfd != NULL);

-  
-  if (!abfd->my_archive)
+
+  if (abfd->my_archive == NULL
+      || bfd_is_thin_archive (abfd->my_archive))

     return bfd_get_filename (abfd);
 
   needed = (strlen (bfd_get_filename (abfd->my_archive))
     return bfd_get_filename (abfd);
 
   needed = (strlen (bfd_get_filename (abfd->my_archive))


@@ -547,16 +651,35 @@ bfd_get_archive_filename (bfd *abfd)
       if (curr)
        free (buf);
       curr = needed + (needed >> 1);
       if (curr)
        free (buf);
       curr = needed + (needed >> 1);

-      buf = bfd_malloc (curr);
-      /* If we can't malloc, fail safe by returning just the file name.
-        This function is only used when building error messages.  */
-      if (!buf)
-       {
-         curr = 0;
-         return bfd_get_filename (abfd);
-       }
+      buf = (char *) xmalloc (curr);

     }
   sprintf (buf, "%s(%s)", bfd_get_filename (abfd->my_archive),
           bfd_get_filename (abfd));
   return buf;
 }
     }
   sprintf (buf, "%s(%s)", bfd_get_filename (abfd->my_archive),
           bfd_get_filename (abfd));
   return buf;
 }

+
+/* Returns TRUE iff PATHNAME, a filename of an archive member,
+   is valid for writing.  For security reasons absolute paths
+   and paths containing /../ are not allowed.  See PR 17533.  */
+
+bfd_boolean
+is_valid_archive_path (char const * pathname)
+{
+  const char * n = pathname;
+
+  if (IS_ABSOLUTE_PATH (n))
+    return FALSE;
+
+  while (*n)
+    {
+      if (*n == '.' && *++n == '.' && ( ! *++n || IS_DIR_SEPARATOR (*n)))
+       return FALSE;
+
+      while (*n && ! IS_DIR_SEPARATOR (*n))
+       n++;
+      while (IS_DIR_SEPARATOR (*n))
+       n++;
+    }
+
+  return TRUE;
+}