Don't use bfd_get_* macro to set bfd fields

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

diff --git a/binutils/coffdump.c b/binutils/coffdump.c
index db5034e0099cf5a8695a86eb93c49a1f79bc64c1..589bb4036244a16c0de14387e12cf82626a4026b 100644 (file)
--- a/binutils/coffdump.c
+++ b/binutils/coffdump.c
@@ -1,12 +1,11 @@
 /* Coff file dumper.
 /* Coff file dumper.

-   Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002
-   Free Software Foundation, Inc.
+   Copyright (C) 1994-2019 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 (at
+   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,
    your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,39 +15,40 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software

-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
+

 
 /* Written by Steve Chamberlain <sac@cygnus.com>
 
    This module reads a type tree generated by coffgrok and prints
    it out so we can test the grokker.  */
 
 
 /* Written by Steve Chamberlain <sac@cygnus.com>
 
    This module reads a type tree generated by coffgrok and prints
    it out so we can test the grokker.  */
 

-#include <bfd.h>
-#include <getopt.h>
-#include <libiberty.h>
+#include "sysdep.h"
+#include "bfd.h"
+#include "bfd_stdint.h"
+#include "libiberty.h"
+#include "bucomm.h"

 
 #include "coffgrok.h"
 
 #include "coffgrok.h"

-#include "bucomm.h"
+#include "getopt.h"

 
 static int atnl;
 
 
 static int atnl;
 

-static void tab PARAMS ((int));
-static void nl PARAMS ((void));
-static void dump_coff_lines PARAMS ((struct coff_line *));
-static void dump_coff_type PARAMS ((struct coff_type *));
-static void dump_coff_where PARAMS ((struct coff_where *));
-static void dump_coff_visible PARAMS ((struct coff_visible *));
-extern void dump_coff_symbol PARAMS ((struct coff_symbol *));
-static void dump_coff_scope PARAMS ((struct coff_scope *));
-static void dump_coff_sfile PARAMS ((struct coff_sfile *));
-static void dump_coff_section PARAMS ((struct coff_section *));
-extern void coff_dump PARAMS ((struct coff_ofile *));
-static void show_usage PARAMS ((FILE *, int));
-extern int main PARAMS ((int, char **));
+static void tab (int);
+static void nl (void);
+static void dump_coff_lines (struct coff_line *);
+static void dump_coff_type (struct coff_type *);
+static void dump_coff_where (struct coff_where *);
+static void dump_coff_visible (struct coff_visible *);
+static void dump_coff_scope (struct coff_scope *);
+static void dump_coff_sfile (struct coff_sfile *);
+static void dump_coff_section (struct coff_section *);
+static void show_usage (FILE *, int);
+extern int main (int, char **);

 
 static void
 
 static void

-tab (x)
-     int x;
+tab (int x)

 {
   static int indent;
   int i;
 {
   static int indent;
   int i;


@@ -91,14 +91,13 @@ tab (x)
 }
 
 static void
 }
 
 static void

-nl ()
+nl (void)

 {
   atnl = 1;
 }
 
 static void
 {
   atnl = 1;
 }
 
 static void

-dump_coff_lines (p)
-     struct coff_line *p;
+dump_coff_lines (struct coff_line *p)

 {
   int i;
   int online = 0;
 {
   int i;
   int online = 0;


@@ -106,7 +105,7 @@ dump_coff_lines (p)
   tab (1);
   printf (_("#lines %d "),p->nlines);
 
   tab (1);
   printf (_("#lines %d "),p->nlines);
 

-  for (i = 0; i < p->nlines; i++) 
+  for (i = 0; i < p->nlines; i++)

     {
       printf ("(%d 0x%x)", p->lines[i], p->addresses[i]);
 
     {
       printf ("(%d 0x%x)", p->lines[i], p->addresses[i]);
 


@@ -124,60 +123,59 @@ dump_coff_lines (p)
 }
 
 static void
 }
 
 static void

-dump_coff_type (p)
-     struct coff_type *p;
+dump_coff_type (struct coff_type *p)

 {
   tab (1);
 {
   tab (1);

-  printf ("size %d ", p->size);
+  printf (_("size %d "), p->size);

 
   switch (p->type)
     {
     case coff_secdef_type:
 
   switch (p->type)
     {
     case coff_secdef_type:

-      printf ("section definition at %x size %x\n", 
+      printf (_("section definition at %x size %x\n"),

              p->u.asecdef.address,
              p->u.asecdef.size);
       nl ();
       break;
     case coff_pointer_type:
              p->u.asecdef.address,
              p->u.asecdef.size);
       nl ();
       break;
     case coff_pointer_type:

-      printf ("pointer to");
+      printf (_("pointer to"));

       nl ();
       dump_coff_type (p->u.pointer.points_to);
       break;
     case coff_array_type:
       nl ();
       dump_coff_type (p->u.pointer.points_to);
       break;
     case coff_array_type:

-      printf ("array [%d] of", p->u.array.dim);
+      printf (_("array [%d] of"), p->u.array.dim);

       nl ();
       dump_coff_type (p->u.array.array_of);
       break;
     case coff_function_type:
       nl ();
       dump_coff_type (p->u.array.array_of);
       break;
     case coff_function_type:

-      printf ("function returning");
+      printf (_("function returning"));

       nl ();
       dump_coff_type (p->u.function.function_returns);
       dump_coff_lines (p->u.function.lines);
       nl ();
       dump_coff_type (p->u.function.function_returns);
       dump_coff_lines (p->u.function.lines);

-      printf ("arguments");
+      printf (_("arguments"));

       nl ();
       dump_coff_scope (p->u.function.parameters);
       tab (0);
       nl ();
       dump_coff_scope (p->u.function.parameters);
       tab (0);

-      printf ("code");
+      printf (_("code"));

       nl ();
       dump_coff_scope (p->u.function.code);
       tab(0);
       break;
     case coff_structdef_type:
       nl ();
       dump_coff_scope (p->u.function.code);
       tab(0);
       break;
     case coff_structdef_type:

-      printf ("structure definition");
+      printf (_("structure definition"));

       nl ();
       dump_coff_scope (p->u.astructdef.elements);
       break;
     case coff_structref_type:
       if (!p->u.aenumref.ref)
       nl ();
       dump_coff_scope (p->u.astructdef.elements);
       break;
     case coff_structref_type:
       if (!p->u.aenumref.ref)

-       printf ("structure ref to UNKNOWN struct");
+       printf (_("structure ref to UNKNOWN struct"));

       else
       else

-       printf ("structure ref to %s", p->u.aenumref.ref->name);
+       printf (_("structure ref to %s"), p->u.aenumref.ref->name);

       break;
     case coff_enumref_type:
       break;
     case coff_enumref_type:

-      printf ("enum ref to %s", p->u.astructref.ref->name);
+      printf (_("enum ref to %s"), p->u.astructref.ref->name);

       break;
     case coff_enumdef_type:
       break;
     case coff_enumdef_type:

-      printf ("enum definition");
+      printf (_("enum definition"));

       nl ();
       dump_coff_scope (p->u.aenumdef.elements);
       break;
       nl ();
       dump_coff_scope (p->u.aenumdef.elements);
       break;


@@ -244,32 +242,32 @@ dump_coff_type (p)
 }
 
 static void
 }
 
 static void

-dump_coff_where (p)
-     struct coff_where *p;
+dump_coff_where (struct coff_where *p)

 {
   tab (1);
   switch (p->where)
     {
     case coff_where_stack:
 {
   tab (1);
   switch (p->where)
     {
     case coff_where_stack:

-      printf ("Stack offset %x", p->offset);
+      printf (_("Stack offset %x"), p->offset);

       break;
     case coff_where_memory:
       break;
     case coff_where_memory:

-      printf ("Memory section %s+%x", p->section->name, p->offset);
+      printf (_("Memory section %s+%x"), p->section->name, p->offset);

       break;
     case coff_where_register:
       break;
     case coff_where_register:

-      printf ("Register %d", p->offset);
+      printf (_("Register %d"), p->offset);

       break;
     case coff_where_member_of_struct:
       break;
     case coff_where_member_of_struct:

-      printf ("Struct Member offset %x", p->offset);
+      printf (_("Struct Member offset %x"), p->offset);

       break;
     case coff_where_member_of_enum:
       break;
     case coff_where_member_of_enum:

-      printf ("Enum Member offset %x", p->offset);
+      printf (_("Enum Member offset %x"), p->offset);

       break;
     case coff_where_unknown:
       break;
     case coff_where_unknown:

-      printf ("Undefined symbol");
+      printf (_("Undefined symbol"));

       break;
     case coff_where_strtag:
       printf ("STRTAG");
       break;
     case coff_where_strtag:
       printf ("STRTAG");

+      break;

     case coff_where_entag:
       printf ("ENTAG");
       break;
     case coff_where_entag:
       printf ("ENTAG");
       break;


@@ -284,8 +282,7 @@ dump_coff_where (p)
 }
 
 static void
 }
 
 static void

-dump_coff_visible (p)
-     struct coff_visible *p;
+dump_coff_visible (struct coff_visible *p)

 {
   tab (1);
   switch (p->type)
 {
   tab (1);
   switch (p->type)


@@ -330,32 +327,31 @@ dump_coff_visible (p)
   tab (-1);
 }
 
   tab (-1);
 }
 

-void
-dump_coff_symbol (p)
-     struct coff_symbol *p;
+static void
+dump_coff_symbol (struct coff_symbol *p)

 {
   tab (1);
 {
   tab (1);

-  printf ("List of symbols");
+  printf (_("List of symbols"));

   nl ();
 
   while (p)
     {
       tab (1);
       tab (1);
   nl ();
 
   while (p)
     {
       tab (1);
       tab (1);

-      printf ("Symbol  %s, tag %d, number %d", p->name, p->tag, p->number);
+      printf (_("Symbol  %s, tag %d, number %d"), p->name, p->tag, p->number);

       nl ();
       tab (-1);
       tab (1);
       nl ();
       tab (-1);
       tab (1);

-      printf ("Type");
+      printf (_("Type"));

       nl ();
       dump_coff_type (p->type);
       tab (-1);
       tab (1);
       nl ();
       dump_coff_type (p->type);
       tab (-1);
       tab (1);

-      printf ("Where");
+      printf (_("Where"));

       dump_coff_where (p->where);
       tab (-1);
       tab (1);
       dump_coff_where (p->where);
       tab (-1);
       tab (1);

-      printf ("Visible");
+      printf (_("Visible"));

       dump_coff_visible (p->visible);
       tab (-1);
       p = p->next;
       dump_coff_visible (p->visible);
       tab (-1);
       p = p->next;


@@ -365,13 +361,13 @@ dump_coff_symbol (p)
 }
 
 static void
 }
 
 static void

-dump_coff_scope (p)
-     struct coff_scope *p;
+dump_coff_scope (struct coff_scope *p)

 {
   if (p)
     {
       tab (1);
 {
   if (p)
     {
       tab (1);

-      printf ("List of blocks %lx ",(unsigned long) p);
+      printf ("%s %" BFD_VMA_FMT "x ",
+             _("List of blocks "), (bfd_vma) (uintptr_t) p);

 
       if (p->sec)
        printf( "  %s %x..%x",  p->sec->name,p->offset, p->offset + p->size -1);
 
       if (p->sec)
        printf( "  %s %x..%x",  p->sec->name,p->offset, p->offset + p->size -1);


@@ -384,10 +380,10 @@ dump_coff_scope (p)
       while (p)
        {
          tab (0);
       while (p)
        {
          tab (0);

-         printf ("vars %d", p->nvars);
+         printf (_("vars %d"), p->nvars);

          nl ();
          dump_coff_symbol (p->vars_head);
          nl ();
          dump_coff_symbol (p->vars_head);

-         printf ("blocks");
+         printf (_("blocks"));

          nl ();
          dump_coff_scope (p->list_head);
          nl ();
          nl ();
          dump_coff_scope (p->list_head);
          nl ();


@@ -402,17 +398,16 @@ dump_coff_scope (p)
 }
 
 static void
 }
 
 static void

-dump_coff_sfile (p)
-     struct coff_sfile *p;
+dump_coff_sfile (struct coff_sfile *p)

 {
   tab (1);
 {
   tab (1);

-  printf ("List of source files");
+  printf (_("List of source files"));

   nl ();
 
   while (p)
     {
       tab (0);
   nl ();
 
   while (p)
     {
       tab (0);

-      printf ("Source file %s", p->name);
+      printf (_("Source file %s"), p->name);

       nl ();
       dump_coff_scope (p->scope);
       p = p->next;
       nl ();
       dump_coff_scope (p->scope);
       p = p->next;


@@ -421,39 +416,39 @@ dump_coff_sfile (p)
 }
 
 static void
 }
 
 static void

-dump_coff_section(ptr)
-     struct coff_section *ptr;
+dump_coff_section (struct coff_section *ptr)

 {
 {

-  int i;
+  unsigned int i;

 
   tab (1);
 
   tab (1);

-  printf ("section %s %d %d address %x size %x number %d nrelocs %d", 
+  printf (_("section %s %d %d address %x size %x number %d nrelocs %u"),

          ptr->name, ptr->code, ptr->data, ptr->address,ptr->size,
          ptr->number, ptr->nrelocs);
   nl ();
 
          ptr->name, ptr->code, ptr->data, ptr->address,ptr->size,
          ptr->number, ptr->nrelocs);
   nl ();
 

-  for (i = 0; i < ptr->nrelocs; i++) 
+  for (i = 0; i < ptr->nrelocs; i++)

     {
     {

-      tab (0);    
+      struct coff_reloc * r = ptr->relocs + i;
+      tab (0);

       printf ("(%x %s %x)",
       printf ("(%x %s %x)",

-             ptr->relocs[i].offset,
-             ptr->relocs[i].symbol->name,
-             ptr->relocs[i].addend);
+             r->offset,
+             /* PR 17512: file: 0a38fb7c.  */
+             r->symbol == NULL ? _("<no sym>") : r->symbol->name,
+             r->addend);

       nl ();
     }
 
   tab (-1);
 }
 
       nl ();
     }
 
   tab (-1);
 }
 

-void
-coff_dump (ptr)
-     struct coff_ofile *ptr;
+static void
+coff_dump (struct coff_ofile *ptr)

 {
   int i;
 
   printf ("Coff dump");
   nl ();
 {
   int i;
 
   printf ("Coff dump");
   nl ();

-  printf ("#souces %d", ptr->nsources);
+  printf (_("#sources %d"), ptr->nsources);

   nl ();
   dump_coff_sfile (ptr->source_head);
 
   nl ();
   dump_coff_sfile (ptr->source_head);
 


@@ -464,27 +459,24 @@ coff_dump (ptr)
 char * program_name;
 
 static void
 char * program_name;
 
 static void

-show_usage (file, status)
-     FILE *file;
-     int status;
+show_usage (FILE *file, int status)

 {
   fprintf (file, _("Usage: %s [option(s)] in-file\n"), program_name);
 {
   fprintf (file, _("Usage: %s [option(s)] in-file\n"), program_name);

-  fprintf (file, _(" Print a human readable interpretation of a SYSROFF object file\n"));
+  fprintf (file, _(" Print a human readable interpretation of a COFF object file\n"));

   fprintf (file, _(" The options are:\n\
   fprintf (file, _(" The options are:\n\

+  @<file>                Read options from <file>\n\

   -h --help              Display this information\n\
   -v --version           Display the program's version\n\
 \n"));
 
   -h --help              Display this information\n\
   -v --version           Display the program's version\n\
 \n"));
 

-  if (status == 0)
+  if (REPORT_BUGS_TO[0] && status == 0)

     fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 
   exit (status);
 }
 
 int
     fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 
   exit (status);
 }
 
 int

-main (ac, av)
-     int ac;
-     char *av[];
+main (int ac, char **av)

 {
   bfd *abfd;
   struct coff_ofile *tree;
 {
   bfd *abfd;
   struct coff_ofile *tree;


@@ -509,6 +501,9 @@ main (ac, av)
 
   program_name = av[0];
   xmalloc_set_program_name (program_name);
 
   program_name = av[0];
   xmalloc_set_program_name (program_name);

+  bfd_set_error_program_name (program_name);
+
+  expandargv (&ac, &av);

 
   while ((opt = getopt_long (ac, av, "HhVv", long_options,
                             (int *) NULL))
 
   while ((opt = getopt_long (ac, av, "HhVv", long_options,
                             (int *) NULL))


@@ -558,9 +553,11 @@ main (ac, av)
     }
 
   tree = coff_grok (abfd);
     }
 
   tree = coff_grok (abfd);

-
-  coff_dump (tree);
-  printf ("\n");
+  if (tree)
+    {
+      coff_dump (tree);
+      printf ("\n");
+    }

 
   return 0;
 }
 
   return 0;
 }