Imported from /home/lorry/working-area/delta_binutils-tarball/binutils-2.25.tar.bz2.HEADbinutils-2.25master

1 files changed, 718 insertions, 0 deletions

diff --git a/binutils/sysdump.c b/binutils/sysdump.c
new file mode 100644
index 0000000..5ae324f
--- /dev/null
+++ b/binutils/sysdump.c
@@ -0,0 +1,718 @@
+/* Sysroff object format dumper.
+   Copyright (C) 1994-2014 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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, 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 "sysdep.h"
+#include "bfd.h"
+#include "safe-ctype.h"
+#include "libiberty.h"
+#include "getopt.h"
+#include "bucomm.h"
+#include "sysroff.h"
+
+static int dump = 1;
+static int segmented_p;
+static int code;
+static int addrsize = 4;
+static FILE *file;
+
+static void dh (unsigned char *, int);
+static void itheader (char *, int);
+static void p (void);
+static void tabout (void);
+static void pbarray (barray *);
+static int getone (int);
+static int opt (int);
+static void must (int);
+static void tab (int, char *);
+static void dump_symbol_info (void);
+static void derived_type (void);
+static void module (void);
+static void show_usage (FILE *, int);
+
+extern int main (int, char **);
+
+static char *
+getCHARS (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 = xcalloc (b + 1, 1);
+  memcpy (r, ptr + oc, b);
+  r[b] = 0;
+
+  return r;
+}
+
+static void
+dh (unsigned char *ptr, int size)
+{
+  int i;
+  int j;
+  int span = 16;
+
+  printf ("\n************************************************************\n");
+
+  for (i = 0; i < size; i += span)
+    {
+      for (j = 0; j < span; j++)
+	{
+	  if (j + i < size)
+	    printf ("%02x ", ptr[i + j]);
+	  else
+	    printf ("   ");
+	}
+
+      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");
+    }
+}
+
+static int
+fillup (unsigned char *ptr)
+{
+  int size;
+  int sum;
+  int i;
+
+  size = getc (file);
+  if (size == EOF
+      || size <= 2)
+    return 0;
+
+  size -= 2;
+  if (fread (ptr, size, 1, file) != 1)
+    return 0;
+
+  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;
+}
+
+static barray
+getBARRAY (unsigned char *ptr, int *idx, int dsize ATTRIBUTE_UNUSED,
+	   int max ATTRIBUTE_UNUSED)
+{
+  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;
+}
+
+static int
+getINT (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 = addrsize;
+
+  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;
+}
+
+static int
+getBITS (unsigned char *ptr, int *idx, int size, int max)
+{
+  int byte = *idx / 8;
+  int bit = *idx % 8;
+
+  if (byte >= max)
+    return 0;
+
+  *idx += size;
+
+  return (ptr[byte] >> (8 - bit - size)) & ((1 << size) - 1);
+}
+
+static void
+itheader (char *name, int icode)
+{
+  printf ("\n%s 0x%02x\n", name, icode);
+}
+
+static int indent;
+
+static void
+p (void)
+{
+  int i;
+
+  for (i = 0; i < indent; i++)
+    printf ("| ");
+
+  printf ("> ");
+}
+
+static void
+tabout (void)
+{
+  p ();
+}
+
+static void
+pbarray (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"
+
+/* FIXME: sysinfo, which generates sysroff.[ch] from sysroff.info, can't
+   hack the special case of the tr block, which has no contents.  So we
+   implement our own functions for reading in and printing out the tr
+   block.  */
+
+#define IT_tr_CODE	0x7f
+
+static void
+sysroff_swap_tr_in (void)
+{
+  unsigned char raw[255];
+
+  memset (raw, 0, 255);
+  fillup (raw);
+}
+
+static void
+sysroff_print_tr_out (void)
+{
+  itheader ("tr", IT_tr_CODE);
+}
+
+static int
+getone (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);
+	addrsize = dummy.afl;
+	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);
+      }
+      break;
+
+    case IT_hs_CODE:
+      {
+	struct IT_hs dummy;
+	sysroff_swap_hs_in (&dummy);
+	sysroff_print_hs_out (&dummy);
+      }
+      break;
+
+    case IT_dps_CODE:
+      {
+	struct IT_dps dummy;
+	sysroff_swap_dps_in (&dummy);
+	sysroff_print_dps_out (&dummy);
+      }
+      break;
+
+    case IT_tr_CODE:
+      sysroff_swap_tr_in ();
+      sysroff_print_tr_out ();
+      break;
+
+    case IT_dds_CODE:
+      {
+	struct IT_dds dummy;
+
+	sysroff_swap_dds_in (&dummy);
+	sysroff_print_dds_out (&dummy);
+      }
+      break;
+
+    default:
+      printf (_("GOT A %x\n"), c);
+      return 0;
+      break;
+    }
+
+  return 1;
+}
+
+static int
+opt (int x)
+{
+  return getone (x);
+}
+
+static void
+must (int x)
+{
+  if (!getone (x))
+    printf (_("WANTED %x!!\n"), x);
+}
+
+static void
+tab (int i, char *s)
+{
+  indent += i;
+
+  if (s)
+    {
+      p ();
+      puts (s);
+    }
+}
+
+static void
+dump_symbol_info (void)
+{
+  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 (void)
+{
+  tab (1, _("DERIVED TYPE"));
+
+  while (1)
+    {
+      if (opt (IT_dpp_CODE))
+	{
+	  dump_symbol_info ();
+	  must (IT_dpp_CODE);
+	}
+      else if (opt (IT_dfp_CODE))
+	{
+	  dump_symbol_info ();
+	  must (IT_dfp_CODE);
+	}
+      else if (opt (IT_den_CODE))
+	{
+	  dump_symbol_info ();
+	  must (IT_den_CODE);
+	}
+      else if (opt (IT_den_CODE))
+	{
+	  dump_symbol_info ();
+	  must (IT_den_CODE);
+	}
+      else if (opt (IT_dds_CODE))
+	{
+	  dump_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
+module (void)
+{
+  int c = 0;
+  int l = 0;
+
+  tab (1, _("MODULE***\n"));
+
+  do
+    {
+      c = getc (file);
+      ungetc (c, file);
+
+      c &= 0x7f;
+    }
+  while (getone (c) && c != IT_tr_CODE);
+
+  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 *ffile, int status)
+{
+  fprintf (ffile, _("Usage: %s [option(s)] in-file\n"), program_name);
+  fprintf (ffile, _("Print a human readable interpretation of a SYSROFF object file\n"));
+  fprintf (ffile, _(" The options are:\n\
+  -h --help        Display this information\n\
+  -v --version     Print the program's version number\n"));
+
+  if (REPORT_BUGS_TO[0] && status == 0)
+    fprintf (ffile, _("Report bugs to %s\n"), REPORT_BUGS_TO);
+  exit (status);
+}
+
+int
+main (int ac, char **av)
+{
+  char *input_file = NULL;
+  int option;
+  static struct option long_options[] =
+  {
+    {"help", no_argument, 0, 'h'},
+    {"version", no_argument, 0, 'V'},
+    {NULL, no_argument, 0, 0}
+  };
+
+#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
+  setlocale (LC_MESSAGES, "");
+#endif
+#if defined (HAVE_SETLOCALE)
+  setlocale (LC_CTYPE, "");
+#endif
+  bindtextdomain (PACKAGE, LOCALEDIR);
+  textdomain (PACKAGE);
+
+  program_name = av[0];
+  xmalloc_set_program_name (program_name);
+
+  expandargv (&ac, &av);
+
+  while ((option = getopt_long (ac, av, "HhVv", long_options, (int *) NULL)) != EOF)
+    {
+      switch (option)
+	{
+	case 'H':
+	case 'h':
+	  show_usage (stdout, 0);
+	  /*NOTREACHED*/
+	case 'v':
+	case 'V':
+	  print_version ("sysdump");
+	  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)
+    fatal (_("no input file specified"));
+
+  file = fopen (input_file, FOPEN_RB);
+
+  if (!file)
+    fatal (_("cannot open input file %s"), input_file);
+
+  module ();
+  return 0;
+}