diff options
| -rw-r--r-- | binutils/ChangeLog | 6 | ||||
| -rw-r--r-- | binutils/Makefile.in | 11 | ||||
| -rw-r--r-- | binutils/sysdump.c | 743 |
3 files changed, 758 insertions, 2 deletions
diff --git a/binutils/ChangeLog b/binutils/ChangeLog index 038e9fc..3f380e8 100644 --- a/binutils/ChangeLog +++ b/binutils/ChangeLog @@ -1,3 +1,9 @@ +Wed Apr 27 11:25:18 1994 Steve Chamberlain (sac@cygnus.com) + + * Makefile.in (syslex, sysinfo): Use CC_FOR_BUILD. + * coffdump.c, coffgroc.c, coffgrog.h, srconv.c, sysdump.c, + sysroff.info: Major changes. + Tue Apr 26 18:18:24 1994 Stan Shebs (shebs@andros.cygnus.com) * objdump.c (print_section_stabs): Indicate the stab header symbol diff --git a/binutils/Makefile.in b/binutils/Makefile.in index cde55b3..e80f4b5 100644 --- a/binutils/Makefile.in +++ b/binutils/Makefile.in @@ -59,7 +59,7 @@ RANLIB = ranlib BISONFLAGS = -d TEXI2ROFF=texi2roff MAKEOVERRIDES= - +CC_FOR_BUILD = $(CC) NM_FOR_TARGET = nm NM = $(NM_FOR_TARGET) SYMLINK = ln -s @@ -278,7 +278,13 @@ syslex.c : syslex.l mv lex.yy.c syslex.c sysinfo: sysinfo.o syslex.o $(ADDL_LIBS) - $(CC) $(CFLAGS) $(LDFLAGS) -o $@ sysinfo.o syslex.o $(ADDL_LIBS) $(EXTRALIBS) + $(CC_FOR_BUILD) $(CFLAGS) $(LDFLAGS) -o $@ sysinfo.o syslex.o + +syslex.o: syslex.c + $(CC_FOR_BUILD) -c -I. $(CFLAGS) syslex.c + +sysinfo.o: sysinfo.c + $(CC_FOR_BUILD) -c -I. $(CFLAGS) sysinfo.c srconv: sysroff.c srconv.o sysroff.c coffgrok.o $(ADDL_LIBS) $(CC) $(CFLAGS) $(LDFLAGS) -o $@ srconv.o coffgrok.o $(ADDL_LIBS) $(EXTRALIBS) @@ -467,6 +473,7 @@ distclean: else true; fi -rm -f Makefile config.status sysdep.h *.o *~ \#* core \ binutils.?? binutils.??s binutils.aux binutils.log binutils.toc + -rm -f $(PROGS) underscore.c realclean: clean distclean -rm -f $(DISTSTUFF) TAGS diff --git a/binutils/sysdump.c b/binutils/sysdump.c new file mode 100644 index 0000000..aa65624 --- /dev/null +++ b/binutils/sysdump.c @@ -0,0 +1,743 @@ +/* Sysroff object format dumper. + Copyright (C) 1994 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 +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +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., 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +/* Written by Steve Chamberlain <sac@cygnus.com>. + + This program reads a SYSROFF object file and prints it in an + almost human readable form to stdout. */ + +#include <stdio.h> +#include <libiberty.h> +#include <getopt.h> +#include "sysroff.h" +#include <stdlib.h> + +#define PROGRAM_VERSION "1.0" + +static int dump = 1; +static int segmented_p; +static int code; +static FILE *file; + +static char *xcalloc(a,b) +int a; +int b; +{ + char *r = xmalloc(a,b); + memset (r, 0, a * b); + return r; +} + +char * +getCHARS (ptr, idx, size, max) + unsigned char *ptr; + int *idx; + int size; + int max; +{ + int oc = *idx / 8; + char *r; + int b = size; + if (b >= max) + { + return "*undefined*"; + } + + if (b == 0) + { + /* Got to work out the length of the string from self */ + b = ptr[oc++]; + (*idx) += 8; + } + + *idx += b * 8; + r = calloc (b + 1, 1); + memcpy (r, ptr + oc, b); + r[b] = 0; + return r; +} +static void +dh (ptr, size) + unsigned char *ptr; + int size; +{ + int i; + int j; + int span = 20; + + printf ("\n************************************************************\n"); + + for (i = 0; i < size; i += span) + { + for (j = 0; j < span && j + i < size; j++) + { + printf ("%02x ", ptr[i + j]); + } + printf ("\n"); + } + + for (i = 0; i < size; i += span) + { + for (j = 0; j < span && j + i < size; j++) + { + int c = ptr[i + j]; + if (c < 32 || c > 127) + c = '.'; + printf (" %c ", c); + } + printf ("\n"); + } +} + +int +fillup (ptr) + char *ptr; +{ + int size; + int sum; + int i; + size = getc (file) - 2; + fread (ptr, 1, size, file); + sum = code + size + 2; + for (i = 0; i < size; i++) + { + sum += ptr[i]; + } + + if ((sum & 0xff) != 0xff) + { + printf ("SUM IS %x\n", sum); + } + if (dump) + dh (ptr, size); + return size; +} + + +barray +getBARRAY (ptr, idx, dsize, max) + unsigned char *ptr; + int *idx; + int dsize; + int max; +{ + barray res; + int i; + int byte = *idx / 8; + int size = ptr[byte++]; + res.len = size; + res.data = (unsigned char *)xmalloc (size); + for (i = 0; i < size; i++) + { + res.data[i] = ptr[byte++]; + } + return res; +} + + + +int +getINT (ptr, idx, size, max) + unsigned char *ptr; + int *idx; + int size; + int max; +{ + int n = 0; + int byte = *idx / 8; + + if (byte >= max) + { + return 0; + } + if (size == -2) + size = 4; + if (size == -1) + size = 0; + switch (size) + { + case 0: + return 0; + case 1: + n = (ptr[byte]); + break; + case 2: + n = (ptr[byte + 0] << 8) + ptr[byte + 1]; + break; + case 4: + n = (ptr[byte + 0] << 24) + (ptr[byte + 1] << 16) + (ptr[byte + 2] << 8) + (ptr[byte + 3]); + break; + default: + abort (); + } + *idx += size * 8; + return n; +} + +int +getBITS (ptr, idx, size) + char *ptr; + int *idx; + int size; +{ + int byte = *idx / 8; + int bit = *idx % 8; + + *idx += size; + + return (ptr[byte] >> (8 - bit - size)) & ((1 << size) - 1); +} + + +static void +itheader (name, code) + char *name; + int code; +{ + printf ("\n%s 0x%02x\n", name, code); +} +static int indent; +static void +p () +{ + int i; + for (i = 0; i < indent; i++) + { + printf ("| "); + } + printf ("> "); +} + +static void +tabout () +{ + p (); +} + +static void +pbarray (y) + barray *y; +{ + int x; + printf ("%d (", y->len); + for (x = 0; x < y->len; x++) + { + printf ("(%02x %c)", y->data[x], isprint (y->data[x]) ? y->data[x] : '.'); + } + printf (")\n"); +} + +#define SYSROFF_PRINT +#define SYSROFF_SWAP_IN + +#include "sysroff.c" + + +static int +getone (type) + int type; +{ + int c = getc (file); + code = c; + + if ((c & 0x7f) != type) + { + ungetc (c, file); + return 0; + } + + switch (c & 0x7f) + { + case IT_cs_CODE: + { + struct IT_cs dummy; + sysroff_swap_cs_in (&dummy); + sysroff_print_cs_out (&dummy); + } + break; + case IT_dln_CODE: + { + struct IT_dln dummy; + sysroff_swap_dln_in (&dummy); + sysroff_print_dln_out (&dummy); + } + break; + case IT_hd_CODE: + { + struct IT_hd dummy; + sysroff_swap_hd_in (&dummy); + sysroff_print_hd_out (&dummy); + } + break; + case IT_dar_CODE: + { + struct IT_dar dummy; + sysroff_swap_dar_in (&dummy); + sysroff_print_dar_out (&dummy); + } + break; + case IT_dsy_CODE: + { + struct IT_dsy dummy; + sysroff_swap_dsy_in (&dummy); + sysroff_print_dsy_out (&dummy); + } + break; + case IT_dfp_CODE: + { + struct IT_dfp dummy; + sysroff_swap_dfp_in (&dummy); + sysroff_print_dfp_out (&dummy); + } + break; + case IT_dso_CODE: + { + struct IT_dso dummy; + sysroff_swap_dso_in (&dummy); + sysroff_print_dso_out (&dummy); + } + break; + case IT_dpt_CODE: + { + struct IT_dpt dummy; + sysroff_swap_dpt_in (&dummy); + sysroff_print_dpt_out (&dummy); + } + break; + case IT_den_CODE: + { + struct IT_den dummy; + sysroff_swap_den_in (&dummy); + sysroff_print_den_out (&dummy); + } + break; + case IT_dbt_CODE: + { + struct IT_dbt dummy; + sysroff_swap_dbt_in (&dummy); + sysroff_print_dbt_out (&dummy); + } + break; + case IT_dty_CODE: + { + struct IT_dty dummy; + sysroff_swap_dty_in (&dummy); + sysroff_print_dty_out (&dummy); + } + break; + case IT_un_CODE: + { + struct IT_un dummy; + sysroff_swap_un_in (&dummy); + sysroff_print_un_out (&dummy); + } + break; + case IT_sc_CODE: + { + struct IT_sc dummy; + sysroff_swap_sc_in (&dummy); + sysroff_print_sc_out (&dummy); + } + break; + case IT_er_CODE: + { + struct IT_er dummy; + sysroff_swap_er_in (&dummy); + sysroff_print_er_out (&dummy); + } + break; + case IT_ed_CODE: + { + struct IT_ed dummy; + sysroff_swap_ed_in (&dummy); + sysroff_print_ed_out (&dummy); + } + break; + case IT_sh_CODE: + { + struct IT_sh dummy; + sysroff_swap_sh_in (&dummy); + sysroff_print_sh_out (&dummy); + } + break; + case IT_ob_CODE: + { + struct IT_ob dummy; + sysroff_swap_ob_in (&dummy); + sysroff_print_ob_out (&dummy); + } + break; + case IT_rl_CODE: + { + struct IT_rl dummy; + sysroff_swap_rl_in (&dummy); + sysroff_print_rl_out (&dummy); + } + break; + case IT_du_CODE: + { + struct IT_du dummy; + sysroff_swap_du_in (&dummy); + + sysroff_print_du_out (&dummy); + } + break; + case IT_dus_CODE: + { + struct IT_dus dummy; + sysroff_swap_dus_in (&dummy); + sysroff_print_dus_out (&dummy); + } + break; + case IT_dul_CODE: + { + struct IT_dul dummy; + sysroff_swap_dul_in (&dummy); + sysroff_print_dul_out (&dummy); + } + break; + case IT_dss_CODE: + { + struct IT_dss dummy; + sysroff_swap_dss_in (&dummy); + sysroff_print_dss_out (&dummy); + } + case IT_hs_CODE: + { + struct IT_hs dummy; + sysroff_swap_hs_in (&dummy); + sysroff_print_hs_out (&dummy); + } + + + case IT_dps_CODE: + { + struct IT_dps dummy; + sysroff_swap_dps_in (&dummy); + sysroff_print_dps_out (&dummy); + } + break; + + + case IT_tr_CODE: + { + struct IT_tr dummy; + sysroff_swap_tr_in (&dummy); + sysroff_print_tr_out (&dummy); + } + break; + case IT_dds_CODE: + { + struct IT_dds dummy; + sysroff_swap_dds_in (&dummy); + sysroff_print_dds_out (&dummy); + } + break; + break; + default: + printf ("GOT A %x\n", c); + return 0; + break; + } + return 1; + +} + +static int +opt (x) + int x; +{ + return getone (x); +} + +static void +unit_info_list () +{ + if (opt (IT_un_CODE)) + { + while (getone (IT_sc_CODE)) + { + getone (IT_ss_CODE); + } + + while (getone (IT_er_CODE)) + { + } + + while (getone (IT_ed_CODE)) + { + } + } +} + +static void +object_body_list () +{ + getone (IT_sh_CODE); + while (getone (IT_ob_CODE)) + ; + while (getone (IT_rl_CODE)) + ; +} + +static void +must (x) + int x; +{ + if (!getone (x)) + { + printf ("WANTED %x!!\n", x); + } +} + +static void +tab (i, s) + int i; + char *s; +{ + indent += i; + if (s) + { + p (); + printf (s); + printf ("\n"); + } +} +static void derived_type (); + +static void +symbol_info () +{ + tab (1, "SYMBOL INFO"); + while (opt (IT_dsy_CODE)) + { + if (opt (IT_dty_CODE)) + { + must (IT_dbt_CODE); + derived_type (); + must (IT_dty_CODE); + } + } + tab (-1, ""); +} + +static void +derived_type () +{ + tab (1, "DERIVED TYPE"); + while (1) + { + if (opt (IT_dpp_CODE)) + { + symbol_info (); + must (IT_dpp_CODE); + } + else if (opt (IT_dfp_CODE)) + { + symbol_info (); + must (IT_dfp_CODE); + } + else if (opt (IT_den_CODE)) + { + symbol_info (); + must (IT_den_CODE); + } + else if (opt (IT_den_CODE)) + { + symbol_info (); + must (IT_den_CODE); + } + else if (opt (IT_dds_CODE)) + { + symbol_info (); + must (IT_dds_CODE); + } + else if (opt (IT_dar_CODE)) + { + } + else if (opt (IT_dpt_CODE)) + { + } + else if (opt (IT_dul_CODE)) + { + } + else if (opt (IT_dse_CODE)) + { + } + else if (opt (IT_dot_CODE)) + { + } + else + break; + } + + tab (-1, ""); +} + +static void +program_structure () +{ + tab (1, "PROGRAM STRUCTURE"); + while (opt (IT_dps_CODE)) + { + opt (IT_dso_CODE); + opt (IT_dss_CODE); + symbol_info (); + } + tab (-1, ""); +} +static void +debug_list () +{ + tab (1, "DEBUG LIST"); + getone (IT_du_CODE); + while (getone (IT_dus_CODE)) + ; + while (opt (IT_dfl_CODE)) + ; + while (getone (IT_dus_CODE)) + ; + + program_structure (); + + getone (IT_dln_CODE); + tab (-1, ""); +} + +static void +module () +{ + int c = 0; + int l = 0; + + tab (1, "MODULE***\n"); + + getone (IT_cs_CODE); + getone (IT_hd_CODE); + getone (IT_hs_CODE); + + while (!opt (IT_tr_CODE) && c < 10) + { + unit_info_list (); + object_body_list (); + debug_list (); +c++; + } + tab (-1, ""); + + c = getc (file); + while (c != EOF) + { + printf ("%02x ", c); + l++; + if (l == 32) + { + printf ("\n"); + l = 0; + } + c = getc (file); + } +} + + +char * program_name; + +static void +show_usage (file, status) + FILE *file; + int status; +{ + fprintf (file, "Usage: %s [-hV] in-file\n", program_name); + exit (status); +} + +static void +show_help () +{ + printf ("%s: Print a human readable interpretation of a SYSROFF object file\n", + program_name); + show_usage (stdout, 0); +} + + +int +main (ac, av) + int ac; + char **av; +{ + char *input_file = NULL; + int opt; + static struct option long_options[] = + { + { "help", no_argument, 0, 'h' }, + { "version", no_argument, 0, 'V' }, + { NULL, no_argument, 0, 0 } + }; + + program_name = av[0]; + xmalloc_set_program_name (program_name); + + while ((opt = getopt_long (ac, av, "hV", long_options, + (int *) NULL)) + != EOF) + { + switch (opt) + { + case 'h': + show_help (); + /*NOTREACHED*/ + case 'V': + printf ("GNU %s version %s\n", program_name, PROGRAM_VERSION); + exit (0); + /*NOTREACHED*/ + case 0: + break; + default: + show_usage (stderr, 1); + /*NOTREACHED*/ + } + } + + /* The input and output files may be named on the command line. */ + + if (optind < ac) + { + input_file = av[optind]; + } + + if (!input_file) + { + fprintf (stderr,"%s: no input file specified\n", + program_name); + exit(1); + } + + file = fopen (input_file, "r"); + if (!file) + { + fprintf (stderr,"%s: cannot open input file %s\n", + program_name, input_file); + exit(1); + } + + + module (); + return 0; +} |