binutils/coffdump.c

   1 /* Coff file dumper.
   2    Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or (at
  10    your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* Written by Steve Chamberlain <sac@cygnus.com>
  22
  23    This module reads a type tree generated by coffgrok and prints
  24    it out so we can test the grokker.  */
  25
  26 #include "bfd.h"
  27 #include "libiberty.h"
  28
  29 #include "coffgrok.h"
  30 #include "bucomm.h"
  31 #include "getopt.h"
  32
  33 static int atnl;
  34
  35 static void tab (int);
  36 static void nl (void);
  37 static void dump_coff_lines (struct coff_line *);
  38 static void dump_coff_type (struct coff_type *);
  39 static void dump_coff_where (struct coff_where *);
  40 static void dump_coff_visible (struct coff_visible *);
  41 extern void dump_coff_symbol (struct coff_symbol *);
  42 static void dump_coff_scope (struct coff_scope *);
  43 static void dump_coff_sfile (struct coff_sfile *);
  44 static void dump_coff_section (struct coff_section *);
  45 extern void coff_dump (struct coff_ofile *);
  46 static void show_usage (FILE *, int);
  47 extern int main (int, char **);
  48
  49 static void
  50 tab (int x)
  51 {
  52   static int indent;
  53   int i;
  54
  55   if (atnl)
  56     {
  57       if (x < 0)
  58         {
  59           printf (")");
  60           indent += x;
  61
  62           return;
  63         }
  64       else
  65         {
  66           printf ("\n");
  67           atnl = 0;
  68         }
  69     }
  70
  71   if (x == -1)
  72     {
  73       for (i = 0; i < indent; i++)
  74         printf ("   ");
  75
  76       indent += x;
  77       printf (")");
  78       return;
  79     }
  80
  81   indent += x;
  82
  83   for (i = 0; i < indent; i++)
  84     printf ("   ");
  85
  86   if (x)
  87     {
  88       printf ("(");
  89     }
  90 }
  91
  92 static void
  93 nl (void)
  94 {
  95   atnl = 1;
  96 }
  97
  98 static void
  99 dump_coff_lines (struct coff_line *p)
 100 {
 101   int i;
 102   int online = 0;
 103
 104   tab (1);
 105   printf (_("#lines %d "),p->nlines);
 106
 107   for (i = 0; i < p->nlines; i++)
 108     {
 109       printf ("(%d 0x%x)", p->lines[i], p->addresses[i]);
 110
 111       online++;
 112
 113       if (online > 6)
 114         {
 115           nl ();
 116           tab (0);
 117           online = 0;
 118         }
 119     }
 120   nl ();
 121   tab (-1);
 122 }
 123
 124 static void
 125 dump_coff_type (struct coff_type *p)
 126 {
 127   tab (1);
 128   printf ("size %d ", p->size);
 129
 130   switch (p->type)
 131     {
 132     case coff_secdef_type:
 133       printf ("section definition at %x size %x\n",
 134               p->u.asecdef.address,
 135               p->u.asecdef.size);
 136       nl ();
 137       break;
 138     case coff_pointer_type:
 139       printf ("pointer to");
 140       nl ();
 141       dump_coff_type (p->u.pointer.points_to);
 142       break;
 143     case coff_array_type:
 144       printf ("array [%d] of", p->u.array.dim);
 145       nl ();
 146       dump_coff_type (p->u.array.array_of);
 147       break;
 148     case coff_function_type:
 149       printf ("function returning");
 150       nl ();
 151       dump_coff_type (p->u.function.function_returns);
 152       dump_coff_lines (p->u.function.lines);
 153       printf ("arguments");
 154       nl ();
 155       dump_coff_scope (p->u.function.parameters);
 156       tab (0);
 157       printf ("code");
 158       nl ();
 159       dump_coff_scope (p->u.function.code);
 160       tab(0);
 161       break;
 162     case coff_structdef_type:
 163       printf ("structure definition");
 164       nl ();
 165       dump_coff_scope (p->u.astructdef.elements);
 166       break;
 167     case coff_structref_type:
 168       if (!p->u.aenumref.ref)
 169         printf ("structure ref to UNKNOWN struct");
 170       else
 171         printf ("structure ref to %s", p->u.aenumref.ref->name);
 172       break;
 173     case coff_enumref_type:
 174       printf ("enum ref to %s", p->u.astructref.ref->name);
 175       break;
 176     case coff_enumdef_type:
 177       printf ("enum definition");
 178       nl ();
 179       dump_coff_scope (p->u.aenumdef.elements);
 180       break;
 181     case coff_basic_type:
 182       switch (p->u.basic)
 183         {
 184         case T_NULL:
 185           printf ("NULL");
 186           break;
 187         case T_VOID:
 188           printf ("VOID");
 189           break;
 190         case T_CHAR:
 191           printf ("CHAR");
 192           break;
 193         case T_SHORT:
 194           printf ("SHORT");
 195           break;
 196         case T_INT:
 197           printf ("INT ");
 198           break;
 199         case T_LONG:
 200           printf ("LONG");
 201           break;
 202         case T_FLOAT:
 203           printf ("FLOAT");
 204           break;
 205         case T_DOUBLE:
 206           printf ("DOUBLE");
 207           break;
 208         case T_STRUCT:
 209           printf ("STRUCT");
 210           break;
 211         case T_UNION:
 212           printf ("UNION");
 213           break;
 214         case T_ENUM:
 215           printf ("ENUM");
 216           break;
 217         case T_MOE:
 218           printf ("MOE ");
 219           break;
 220         case T_UCHAR:
 221           printf ("UCHAR");
 222           break;
 223         case T_USHORT:
 224           printf ("USHORT");
 225           break;
 226         case T_UINT:
 227           printf ("UINT");
 228           break;
 229         case T_ULONG:
 230           printf ("ULONG");
 231           break;
 232         case T_LNGDBL:
 233           printf ("LNGDBL");
 234           break;
 235         default:
 236           abort ();
 237         }
 238     }
 239   nl ();
 240   tab (-1);
 241 }
 242
 243 static void
 244 dump_coff_where (struct coff_where *p)
 245 {
 246   tab (1);
 247   switch (p->where)
 248     {
 249     case coff_where_stack:
 250       printf ("Stack offset %x", p->offset);
 251       break;
 252     case coff_where_memory:
 253       printf ("Memory section %s+%x", p->section->name, p->offset);
 254       break;
 255     case coff_where_register:
 256       printf ("Register %d", p->offset);
 257       break;
 258     case coff_where_member_of_struct:
 259       printf ("Struct Member offset %x", p->offset);
 260       break;
 261     case coff_where_member_of_enum:
 262       printf ("Enum Member offset %x", p->offset);
 263       break;
 264     case coff_where_unknown:
 265       printf ("Undefined symbol");
 266       break;
 267     case coff_where_strtag:
 268       printf ("STRTAG");
 269     case coff_where_entag:
 270       printf ("ENTAG");
 271       break;
 272     case coff_where_typedef:
 273       printf ("TYPEDEF");
 274       break;
 275     default:
 276       abort ();
 277     }
 278   nl ();
 279   tab (-1);
 280 }
 281
 282 static void
 283 dump_coff_visible (struct coff_visible *p)
 284 {
 285   tab (1);
 286   switch (p->type)
 287     {
 288     case coff_vis_ext_def:
 289       printf ("coff_vis_ext_def");
 290       break;
 291     case coff_vis_ext_ref:
 292       printf ("coff_vis_ext_ref");
 293       break;
 294     case coff_vis_int_def:
 295       printf ("coff_vis_int_def");
 296       break;
 297     case coff_vis_common:
 298       printf ("coff_vis_common");
 299       break;
 300     case coff_vis_auto:
 301       printf ("coff_vis_auto");
 302       break;
 303     case coff_vis_autoparam:
 304       printf ("coff_vis_autoparam");
 305       break;
 306     case coff_vis_regparam:
 307       printf ("coff_vis_regparam");
 308       break;
 309     case coff_vis_register:
 310       printf ("coff_vis_register");
 311       break;
 312     case coff_vis_tag:
 313       printf ("coff_vis_tag");
 314       break;
 315     case coff_vis_member_of_struct:
 316       printf ("coff_vis_member_of_struct");
 317       break;
 318     case coff_vis_member_of_enum:
 319       printf ("coff_vis_member_of_enum");
 320       break;
 321     default:
 322       abort ();
 323     }
 324   nl ();
 325   tab (-1);
 326 }
 327
 328 void
 329 dump_coff_symbol (struct coff_symbol *p)
 330 {
 331   tab (1);
 332   printf ("List of symbols");
 333   nl ();
 334
 335   while (p)
 336     {
 337       tab (1);
 338       tab (1);
 339       printf ("Symbol  %s, tag %d, number %d", p->name, p->tag, p->number);
 340       nl ();
 341       tab (-1);
 342       tab (1);
 343       printf ("Type");
 344       nl ();
 345       dump_coff_type (p->type);
 346       tab (-1);
 347       tab (1);
 348       printf ("Where");
 349       dump_coff_where (p->where);
 350       tab (-1);
 351       tab (1);
 352       printf ("Visible");
 353       dump_coff_visible (p->visible);
 354       tab (-1);
 355       p = p->next;
 356       tab (-1);
 357     }
 358   tab (-1);
 359 }
 360
 361 static void
 362 dump_coff_scope (struct coff_scope *p)
 363 {
 364   if (p)
 365     {
 366       tab (1);
 367       printf ("List of blocks %lx ",(unsigned long) p);
 368
 369       if (p->sec)
 370         printf( "  %s %x..%x",  p->sec->name,p->offset, p->offset + p->size -1);
 371
 372       nl ();
 373       tab (0);
 374       printf ("*****************");
 375       nl ();
 376
 377       while (p)
 378         {
 379           tab (0);
 380           printf ("vars %d", p->nvars);
 381           nl ();
 382           dump_coff_symbol (p->vars_head);
 383           printf ("blocks");
 384           nl ();
 385           dump_coff_scope (p->list_head);
 386           nl ();
 387           p = p->next;
 388         }
 389
 390       tab (0);
 391       printf ("*****************");
 392       nl ();
 393       tab (-1);
 394     }
 395 }
 396
 397 static void
 398 dump_coff_sfile (struct coff_sfile *p)
 399 {
 400   tab (1);
 401   printf ("List of source files");
 402   nl ();
 403
 404   while (p)
 405     {
 406       tab (0);
 407       printf ("Source file %s", p->name);
 408       nl ();
 409       dump_coff_scope (p->scope);
 410       p = p->next;
 411     }
 412   tab (-1);
 413 }
 414
 415 static void
 416 dump_coff_section (struct coff_section *ptr)
 417 {
 418   int i;
 419
 420   tab (1);
 421   printf ("section %s %d %d address %x size %x number %d nrelocs %d",
 422           ptr->name, ptr->code, ptr->data, ptr->address,ptr->size,
 423           ptr->number, ptr->nrelocs);
 424   nl ();
 425
 426   for (i = 0; i < ptr->nrelocs; i++)
 427     {
 428       tab (0);
 429       printf ("(%x %s %x)",
 430               ptr->relocs[i].offset,
 431               ptr->relocs[i].symbol->name,
 432               ptr->relocs[i].addend);
 433       nl ();
 434     }
 435
 436   tab (-1);
 437 }
 438
 439 void
 440 coff_dump (struct coff_ofile *ptr)
 441 {
 442   int i;
 443
 444   printf ("Coff dump");
 445   nl ();
 446   printf ("#souces %d", ptr->nsources);
 447   nl ();
 448   dump_coff_sfile (ptr->source_head);
 449
 450   for (i = 0; i < ptr->nsections; i++)
 451     dump_coff_section (ptr->sections + i);
 452 }
 453
 454 char * program_name;
 455
 456 static void
 457 show_usage (FILE *file, int status)
 458 {
 459   fprintf (file, _("Usage: %s [option(s)] in-file\n"), program_name);
 460   fprintf (file, _(" Print a human readable interpretation of a SYSROFF object file\n"));
 461   fprintf (file, _(" The options are:\n\
 462   -h --help              Display this information\n\
 463   -v --version           Display the program's version\n\
 464 \n"));
 465
 466   if (status == 0)
 467     fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 468
 469   exit (status);
 470 }
 471
 472 int
 473 main (int ac, char **av)
 474 {
 475   bfd *abfd;
 476   struct coff_ofile *tree;
 477   char **matching;
 478   char *input_file = NULL;
 479   int opt;
 480   static struct option long_options[] =
 481     {
 482       { "help", no_argument, 0, 'h' },
 483       { "version", no_argument, 0, 'V' },
 484       { NULL, no_argument, 0, 0 }
 485     };
 486
 487 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 488   setlocale (LC_MESSAGES, "");
 489 #endif
 490 #if defined (HAVE_SETLOCALE)
 491   setlocale (LC_CTYPE, "");
 492 #endif
 493   bindtextdomain (PACKAGE, LOCALEDIR);
 494   textdomain (PACKAGE);
 495
 496   program_name = av[0];
 497   xmalloc_set_program_name (program_name);
 498
 499   while ((opt = getopt_long (ac, av, "HhVv", long_options,
 500                              (int *) NULL))
 501          != EOF)
 502     {
 503       switch (opt)
 504         {
 505         case 'H':
 506         case 'h':
 507           show_usage (stdout, 0);
 508           break;
 509         case 'v':
 510         case 'V':
 511           print_version ("coffdump");
 512           exit (0);
 513         case 0:
 514           break;
 515         default:
 516           show_usage (stderr, 1);
 517           break;
 518         }
 519     }
 520
 521   if (optind < ac)
 522     {
 523       input_file = av[optind];
 524     }
 525
 526   if (!input_file)
 527     fatal (_("no input file specified"));
 528
 529   abfd = bfd_openr (input_file, 0);
 530
 531   if (!abfd)
 532     bfd_fatal (input_file);
 533
 534   if (! bfd_check_format_matches (abfd, bfd_object, &matching))
 535     {
 536       bfd_nonfatal (input_file);
 537
 538       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 539         {
 540           list_matching_formats (matching);
 541           free (matching);
 542         }
 543       exit (1);
 544     }
 545
 546   tree = coff_grok (abfd);
 547
 548   coff_dump (tree);
 549   printf ("\n");
 550
 551   return 0;
 552 }