daily update
[binutils.git] / binutils / sysdump.c
blob6b3fbdaec04f071226ff26c97925fbabcf2b7ef1
1 /* Sysroff object format dumper.
2 Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2007
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
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 3 of the License, or
10 (at your option) any later version.
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.
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., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
23 /* Written by Steve Chamberlain <sac@cygnus.com>.
25 This program reads a SYSROFF object file and prints it in an
26 almost human readable form to stdout. */
28 #include "sysdep.h"
29 #include "bfd.h"
30 #include "safe-ctype.h"
31 #include "libiberty.h"
32 #include "getopt.h"
33 #include "bucomm.h"
34 #include "sysroff.h"
36 static int dump = 1;
37 static int segmented_p;
38 static int code;
39 static int addrsize = 4;
40 static FILE *file;
42 static void dh (unsigned char *, int);
43 static void itheader (char *, int);
44 static void p (void);
45 static void tabout (void);
46 static void pbarray (barray *);
47 static int getone (int);
48 static int opt (int);
49 static void must (int);
50 static void tab (int, char *);
51 static void dump_symbol_info (void);
52 static void derived_type (void);
53 static void module (void);
54 static void show_usage (FILE *, int);
56 extern int main (int, char **);
58 static char *
59 getCHARS (unsigned char *ptr, int *idx, int size, int max)
61 int oc = *idx / 8;
62 char *r;
63 int b = size;
65 if (b >= max)
66 return "*undefined*";
68 if (b == 0)
70 /* Got to work out the length of the string from self. */
71 b = ptr[oc++];
72 (*idx) += 8;
75 *idx += b * 8;
76 r = xcalloc (b + 1, 1);
77 memcpy (r, ptr + oc, b);
78 r[b] = 0;
80 return r;
83 static void
84 dh (unsigned char *ptr, int size)
86 int i;
87 int j;
88 int span = 16;
90 printf ("\n************************************************************\n");
92 for (i = 0; i < size; i += span)
94 for (j = 0; j < span; j++)
96 if (j + i < size)
97 printf ("%02x ", ptr[i + j]);
98 else
99 printf (" ");
102 for (j = 0; j < span && j + i < size; j++)
104 int c = ptr[i + j];
106 if (c < 32 || c > 127)
107 c = '.';
108 printf ("%c", c);
111 printf ("\n");
115 static int
116 fillup (unsigned char *ptr)
118 int size;
119 int sum;
120 int i;
122 size = getc (file) - 2;
123 fread (ptr, 1, size, file);
124 sum = code + size + 2;
126 for (i = 0; i < size; i++)
127 sum += ptr[i];
129 if ((sum & 0xff) != 0xff)
130 printf ("SUM IS %x\n", sum);
132 if (dump)
133 dh (ptr, size);
135 return size - 1;
138 static barray
139 getBARRAY (unsigned char *ptr, int *idx, int dsize ATTRIBUTE_UNUSED,
140 int max ATTRIBUTE_UNUSED)
142 barray res;
143 int i;
144 int byte = *idx / 8;
145 int size = ptr[byte++];
147 res.len = size;
148 res.data = (unsigned char *) xmalloc (size);
150 for (i = 0; i < size; i++)
151 res.data[i] = ptr[byte++];
153 return res;
156 static int
157 getINT (unsigned char *ptr, int *idx, int size, int max)
159 int n = 0;
160 int byte = *idx / 8;
162 if (byte >= max)
163 return 0;
165 if (size == -2)
166 size = addrsize;
168 if (size == -1)
169 size = 0;
171 switch (size)
173 case 0:
174 return 0;
175 case 1:
176 n = (ptr[byte]);
177 break;
178 case 2:
179 n = (ptr[byte + 0] << 8) + ptr[byte + 1];
180 break;
181 case 4:
182 n = (ptr[byte + 0] << 24) + (ptr[byte + 1] << 16) + (ptr[byte + 2] << 8) + (ptr[byte + 3]);
183 break;
184 default:
185 abort ();
188 *idx += size * 8;
189 return n;
192 static int
193 getBITS (unsigned char *ptr, int *idx, int size, int max)
195 int byte = *idx / 8;
196 int bit = *idx % 8;
198 if (byte >= max)
199 return 0;
201 *idx += size;
203 return (ptr[byte] >> (8 - bit - size)) & ((1 << size) - 1);
206 static void
207 itheader (char *name, int code)
209 printf ("\n%s 0x%02x\n", name, code);
212 static int indent;
214 static void
215 p (void)
217 int i;
219 for (i = 0; i < indent; i++)
220 printf ("| ");
222 printf ("> ");
225 static void
226 tabout (void)
228 p ();
231 static void
232 pbarray (barray *y)
234 int x;
236 printf ("%d (", y->len);
238 for (x = 0; x < y->len; x++)
239 printf ("(%02x %c)", y->data[x],
240 ISPRINT (y->data[x]) ? y->data[x] : '.');
242 printf (")\n");
245 #define SYSROFF_PRINT
246 #define SYSROFF_SWAP_IN
248 #include "sysroff.c"
250 /* FIXME: sysinfo, which generates sysroff.[ch] from sysroff.info, can't
251 hack the special case of the tr block, which has no contents. So we
252 implement our own functions for reading in and printing out the tr
253 block. */
255 #define IT_tr_CODE 0x7f
257 static void
258 sysroff_swap_tr_in (void)
260 unsigned char raw[255];
262 memset (raw, 0, 255);
263 fillup (raw);
266 static void
267 sysroff_print_tr_out (void)
269 itheader ("tr", IT_tr_CODE);
272 static int
273 getone (int type)
275 int c = getc (file);
277 code = c;
279 if ((c & 0x7f) != type)
281 ungetc (c, file);
282 return 0;
285 switch (c & 0x7f)
287 case IT_cs_CODE:
289 struct IT_cs dummy;
290 sysroff_swap_cs_in (&dummy);
291 sysroff_print_cs_out (&dummy);
293 break;
295 case IT_dln_CODE:
297 struct IT_dln dummy;
298 sysroff_swap_dln_in (&dummy);
299 sysroff_print_dln_out (&dummy);
301 break;
303 case IT_hd_CODE:
305 struct IT_hd dummy;
306 sysroff_swap_hd_in (&dummy);
307 addrsize = dummy.afl;
308 sysroff_print_hd_out (&dummy);
310 break;
312 case IT_dar_CODE:
314 struct IT_dar dummy;
315 sysroff_swap_dar_in (&dummy);
316 sysroff_print_dar_out (&dummy);
318 break;
320 case IT_dsy_CODE:
322 struct IT_dsy dummy;
323 sysroff_swap_dsy_in (&dummy);
324 sysroff_print_dsy_out (&dummy);
326 break;
328 case IT_dfp_CODE:
330 struct IT_dfp dummy;
331 sysroff_swap_dfp_in (&dummy);
332 sysroff_print_dfp_out (&dummy);
334 break;
336 case IT_dso_CODE:
338 struct IT_dso dummy;
339 sysroff_swap_dso_in (&dummy);
340 sysroff_print_dso_out (&dummy);
342 break;
344 case IT_dpt_CODE:
346 struct IT_dpt dummy;
347 sysroff_swap_dpt_in (&dummy);
348 sysroff_print_dpt_out (&dummy);
350 break;
352 case IT_den_CODE:
354 struct IT_den dummy;
355 sysroff_swap_den_in (&dummy);
356 sysroff_print_den_out (&dummy);
358 break;
360 case IT_dbt_CODE:
362 struct IT_dbt dummy;
363 sysroff_swap_dbt_in (&dummy);
364 sysroff_print_dbt_out (&dummy);
366 break;
368 case IT_dty_CODE:
370 struct IT_dty dummy;
371 sysroff_swap_dty_in (&dummy);
372 sysroff_print_dty_out (&dummy);
374 break;
376 case IT_un_CODE:
378 struct IT_un dummy;
379 sysroff_swap_un_in (&dummy);
380 sysroff_print_un_out (&dummy);
382 break;
384 case IT_sc_CODE:
386 struct IT_sc dummy;
387 sysroff_swap_sc_in (&dummy);
388 sysroff_print_sc_out (&dummy);
390 break;
392 case IT_er_CODE:
394 struct IT_er dummy;
395 sysroff_swap_er_in (&dummy);
396 sysroff_print_er_out (&dummy);
398 break;
400 case IT_ed_CODE:
402 struct IT_ed dummy;
403 sysroff_swap_ed_in (&dummy);
404 sysroff_print_ed_out (&dummy);
406 break;
408 case IT_sh_CODE:
410 struct IT_sh dummy;
411 sysroff_swap_sh_in (&dummy);
412 sysroff_print_sh_out (&dummy);
414 break;
416 case IT_ob_CODE:
418 struct IT_ob dummy;
419 sysroff_swap_ob_in (&dummy);
420 sysroff_print_ob_out (&dummy);
422 break;
424 case IT_rl_CODE:
426 struct IT_rl dummy;
427 sysroff_swap_rl_in (&dummy);
428 sysroff_print_rl_out (&dummy);
430 break;
432 case IT_du_CODE:
434 struct IT_du dummy;
435 sysroff_swap_du_in (&dummy);
437 sysroff_print_du_out (&dummy);
439 break;
441 case IT_dus_CODE:
443 struct IT_dus dummy;
444 sysroff_swap_dus_in (&dummy);
445 sysroff_print_dus_out (&dummy);
447 break;
449 case IT_dul_CODE:
451 struct IT_dul dummy;
452 sysroff_swap_dul_in (&dummy);
453 sysroff_print_dul_out (&dummy);
455 break;
457 case IT_dss_CODE:
459 struct IT_dss dummy;
460 sysroff_swap_dss_in (&dummy);
461 sysroff_print_dss_out (&dummy);
463 break;
465 case IT_hs_CODE:
467 struct IT_hs dummy;
468 sysroff_swap_hs_in (&dummy);
469 sysroff_print_hs_out (&dummy);
471 break;
473 case IT_dps_CODE:
475 struct IT_dps dummy;
476 sysroff_swap_dps_in (&dummy);
477 sysroff_print_dps_out (&dummy);
479 break;
481 case IT_tr_CODE:
482 sysroff_swap_tr_in ();
483 sysroff_print_tr_out ();
484 break;
486 case IT_dds_CODE:
488 struct IT_dds dummy;
490 sysroff_swap_dds_in (&dummy);
491 sysroff_print_dds_out (&dummy);
493 break;
495 default:
496 printf ("GOT A %x\n", c);
497 return 0;
498 break;
501 return 1;
504 static int
505 opt (int x)
507 return getone (x);
510 static void
511 must (int x)
513 if (!getone (x))
514 printf ("WANTED %x!!\n", x);
517 static void
518 tab (int i, char *s)
520 indent += i;
522 if (s)
524 p ();
525 printf (s);
526 printf ("\n");
530 static void
531 dump_symbol_info (void)
533 tab (1, "SYMBOL INFO");
535 while (opt (IT_dsy_CODE))
537 if (opt (IT_dty_CODE))
539 must (IT_dbt_CODE);
540 derived_type ();
541 must (IT_dty_CODE);
545 tab (-1, "");
548 static void
549 derived_type (void)
551 tab (1, "DERIVED TYPE");
553 while (1)
555 if (opt (IT_dpp_CODE))
557 dump_symbol_info ();
558 must (IT_dpp_CODE);
560 else if (opt (IT_dfp_CODE))
562 dump_symbol_info ();
563 must (IT_dfp_CODE);
565 else if (opt (IT_den_CODE))
567 dump_symbol_info ();
568 must (IT_den_CODE);
570 else if (opt (IT_den_CODE))
572 dump_symbol_info ();
573 must (IT_den_CODE);
575 else if (opt (IT_dds_CODE))
577 dump_symbol_info ();
578 must (IT_dds_CODE);
580 else if (opt (IT_dar_CODE))
583 else if (opt (IT_dpt_CODE))
586 else if (opt (IT_dul_CODE))
589 else if (opt (IT_dse_CODE))
592 else if (opt (IT_dot_CODE))
595 else
596 break;
599 tab (-1, "");
602 static void
603 module (void)
605 int c = 0;
606 int l = 0;
608 tab (1, "MODULE***\n");
612 c = getc (file);
613 ungetc (c, file);
615 c &= 0x7f;
617 while (getone (c) && c != IT_tr_CODE);
619 tab (-1, "");
621 c = getc (file);
622 while (c != EOF)
624 printf ("%02x ", c);
625 l++;
626 if (l == 32)
628 printf ("\n");
629 l = 0;
631 c = getc (file);
635 char *program_name;
637 static void
638 show_usage (FILE *file, int status)
640 fprintf (file, _("Usage: %s [option(s)] in-file\n"), program_name);
641 fprintf (file, _("Print a human readable interpretation of a SYSROFF object file\n"));
642 fprintf (file, _(" The options are:\n\
643 -h --help Display this information\n\
644 -v --version Print the program's version number\n"));
646 if (REPORT_BUGS_TO[0] && status == 0)
647 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
648 exit (status);
652 main (int ac, char **av)
654 char *input_file = NULL;
655 int opt;
656 static struct option long_options[] =
658 {"help", no_argument, 0, 'h'},
659 {"version", no_argument, 0, 'V'},
660 {NULL, no_argument, 0, 0}
663 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
664 setlocale (LC_MESSAGES, "");
665 #endif
666 #if defined (HAVE_SETLOCALE)
667 setlocale (LC_CTYPE, "");
668 #endif
669 bindtextdomain (PACKAGE, LOCALEDIR);
670 textdomain (PACKAGE);
672 program_name = av[0];
673 xmalloc_set_program_name (program_name);
675 expandargv (&ac, &av);
677 while ((opt = getopt_long (ac, av, "HhVv", long_options, (int *) NULL)) != EOF)
679 switch (opt)
681 case 'H':
682 case 'h':
683 show_usage (stdout, 0);
684 /*NOTREACHED*/
685 case 'v':
686 case 'V':
687 print_version ("sysdump");
688 exit (0);
689 /*NOTREACHED*/
690 case 0:
691 break;
692 default:
693 show_usage (stderr, 1);
694 /*NOTREACHED*/
698 /* The input and output files may be named on the command line. */
700 if (optind < ac)
701 input_file = av[optind];
703 if (!input_file)
704 fatal (_("no input file specified"));
706 file = fopen (input_file, FOPEN_RB);
708 if (!file)
709 fatal (_("cannot open input file %s"), input_file);
711 module ();
712 return 0;