2004-11-01 Andrew Cagney <cagney@gnu.org>

	* configure.tgt: Mark d10v-*-* as obsolete.
	* config/d10v/d10v.mt, d10v-tdep.c: Obsolete files.

4 files changed, 1589 insertions, 1584 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 05c2613..18bbe03 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2004-11-01  Andrew Cagney  <cagney@gnu.org>
+
+	* configure.tgt: Mark d10v-*-* as obsolete.
+	* config/d10v/d10v.mt, d10v-tdep.c: Obsolete files.
+
 2004-11-01  Paul N. Hilfinger  <Hilfinger@gnat.com>
 
 	* values.c (modify_field): Correct handling of bit-fields that
diff --git a/gdb/config/d10v/d10v.mt b/gdb/config/d10v/d10v.mt
index 805ce76..58d3dda 100644
--- a/gdb/config/d10v/d10v.mt
+++ b/gdb/config/d10v/d10v.mt
@@ -1,4 +1,4 @@
-# Target: Renesas D10V processor
-TDEPFILES= d10v-tdep.o
-SIM_OBS= remote-sim.o
-SIM= ../sim/d10v/libsim.a
+# OBSOLETE # Target: Renesas D10V processor
+# OBSOLETE TDEPFILES= d10v-tdep.o
+# OBSOLETE SIM_OBS= remote-sim.o
+# OBSOLETE SIM= ../sim/d10v/libsim.a
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index fed1c0e..3e27c44 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -69,7 +69,7 @@ avr-*-*)		gdb_target=avr ;;
 
 cris*)                  gdb_target=cris ;;
 
-d10v-*-*)		gdb_target=d10v ;;
+# OBSOLETE d10v-*-*)		gdb_target=d10v ;;
 
 h8300-*-*)		gdb_target=h8300 ;;
 
diff --git a/gdb/d10v-tdep.c b/gdb/d10v-tdep.c
index b0da9be..be59f23 100644
--- a/gdb/d10v-tdep.c
+++ b/gdb/d10v-tdep.c
@@ -1,1579 +1,1579 @@
-/* Target-dependent code for Renesas D10V, for GDB.
-
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
-   Foundation, Inc.
-
-   This file is part of GDB.
-
-   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., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
-
-/*  Contributed by Martin Hunt, hunt@cygnus.com */
-
-#include "defs.h"
-#include "frame.h"
-#include "frame-unwind.h"
-#include "frame-base.h"
-#include "symtab.h"
-#include "gdbtypes.h"
-#include "gdbcmd.h"
-#include "gdbcore.h"
-#include "gdb_string.h"
-#include "value.h"
-#include "inferior.h"
-#include "dis-asm.h"
-#include "symfile.h"
-#include "objfiles.h"
-#include "language.h"
-#include "arch-utils.h"
-#include "regcache.h"
-#include "remote.h"
-#include "floatformat.h"
-#include "gdb/sim-d10v.h"
-#include "sim-regno.h"
-#include "disasm.h"
-#include "trad-frame.h"
-
-#include "gdb_assert.h"
-
-struct gdbarch_tdep
-  {
-    int a0_regnum;
-    int nr_dmap_regs;
-    unsigned long (*dmap_register) (void *regcache, int nr);
-    unsigned long (*imap_register) (void *regcache, int nr);
-  };
-
-/* These are the addresses the D10V-EVA board maps data and
-   instruction memory to.  */
-
-enum memspace {
-  DMEM_START  = 0x2000000,
-  IMEM_START  = 0x1000000,
-  STACK_START = 0x200bffe
-};
-
-/* d10v register names.  */
-
-enum
-  {
-    R0_REGNUM = 0,
-    R3_REGNUM = 3,
-    D10V_FP_REGNUM = 11,
-    LR_REGNUM = 13,
-    D10V_SP_REGNUM = 15,
-    PSW_REGNUM = 16,
-    D10V_PC_REGNUM = 18,
-    NR_IMAP_REGS = 2,
-    NR_A_REGS = 2,
-    TS2_NUM_REGS = 37,
-    TS3_NUM_REGS = 42,
-    /* d10v calling convention.  */
-    ARG1_REGNUM = R0_REGNUM,
-    ARGN_REGNUM = R3_REGNUM
-  };
-
-static int
-nr_dmap_regs (struct gdbarch *gdbarch)
-{
-  return gdbarch_tdep (gdbarch)->nr_dmap_regs;
-}
-
-static int
-a0_regnum (struct gdbarch *gdbarch)
-{
-  return gdbarch_tdep (gdbarch)->a0_regnum;
-}
-
-/* Local functions */
-
-extern void _initialize_d10v_tdep (void);
-
-static void d10v_eva_prepare_to_trace (void);
-
-static void d10v_eva_get_trace_data (void);
-
-static CORE_ADDR
-d10v_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
-{
-  /* Align to the size of an instruction (so that they can safely be
-     pushed onto the stack.  */
-  return sp & ~3;
-}
-
-static const unsigned char *
-d10v_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
-{
-  static unsigned char breakpoint[] =
-  {0x2f, 0x90, 0x5e, 0x00};
-  *lenptr = sizeof (breakpoint);
-  return breakpoint;
-}
-
-/* Map the REG_NR onto an ascii name.  Return NULL or an empty string
-   when the reg_nr isn't valid.  */
-
-enum ts2_regnums
-  {
-    TS2_IMAP0_REGNUM = 32,
-    TS2_DMAP_REGNUM = 34,
-    TS2_NR_DMAP_REGS = 1,
-    TS2_A0_REGNUM = 35
-  };
-
-static const char *
-d10v_ts2_register_name (int reg_nr)
-{
-  static char *register_names[] =
-  {
-    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
-    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
-    "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
-    "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
-    "imap0", "imap1", "dmap", "a0", "a1"
-  };
-  if (reg_nr < 0)
-    return NULL;
-  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
-    return NULL;
-  return register_names[reg_nr];
-}
-
-enum ts3_regnums
-  {
-    TS3_IMAP0_REGNUM = 36,
-    TS3_DMAP0_REGNUM = 38,
-    TS3_NR_DMAP_REGS = 4,
-    TS3_A0_REGNUM = 32
-  };
-
-static const char *
-d10v_ts3_register_name (int reg_nr)
-{
-  static char *register_names[] =
-  {
-    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
-    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
-    "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
-    "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
-    "a0", "a1",
-    "spi", "spu",
-    "imap0", "imap1",
-    "dmap0", "dmap1", "dmap2", "dmap3"
-  };
-  if (reg_nr < 0)
-    return NULL;
-  if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
-    return NULL;
-  return register_names[reg_nr];
-}
-
-/* Access the DMAP/IMAP registers in a target independent way.
-
-   Divide the D10V's 64k data space into four 16k segments:
-   0x0000 -- 0x3fff, 0x4000 -- 0x7fff, 0x8000 -- 0xbfff, and 
-   0xc000 -- 0xffff.
-
-   On the TS2, the first two segments (0x0000 -- 0x3fff, 0x4000 --
-   0x7fff) always map to the on-chip data RAM, and the fourth always
-   maps to I/O space.  The third (0x8000 - 0xbfff) can be mapped into
-   unified memory or instruction memory, under the control of the
-   single DMAP register.
-
-   On the TS3, there are four DMAP registers, each of which controls
-   one of the segments.  */
-
-static unsigned long
-d10v_ts2_dmap_register (void *regcache, int reg_nr)
-{
-  switch (reg_nr)
-    {
-    case 0:
-    case 1:
-      return 0x2000;
-    case 2:
-      {
-	ULONGEST reg;
-	regcache_cooked_read_unsigned (regcache, TS2_DMAP_REGNUM, &reg);
-	return reg;
-      }
-    default:
-      return 0;
-    }
-}
-
-static unsigned long
-d10v_ts3_dmap_register (void *regcache, int reg_nr)
-{
-  ULONGEST reg;
-  regcache_cooked_read_unsigned (regcache, TS3_DMAP0_REGNUM + reg_nr, &reg);
-  return reg;
-}
-
-static unsigned long
-d10v_ts2_imap_register (void *regcache, int reg_nr)
-{
-  ULONGEST reg;
-  regcache_cooked_read_unsigned (regcache, TS2_IMAP0_REGNUM + reg_nr, &reg);
-  return reg;
-}
-
-static unsigned long
-d10v_ts3_imap_register (void *regcache, int reg_nr)
-{
-  ULONGEST reg;
-  regcache_cooked_read_unsigned (regcache, TS3_IMAP0_REGNUM + reg_nr, &reg);
-  return reg;
-}
-
-/* MAP GDB's internal register numbering (determined by the layout
-   from the DEPRECATED_REGISTER_BYTE array) onto the simulator's
-   register numbering.  */
-
-static int
-d10v_ts2_register_sim_regno (int nr)
-{
-  /* Only makes sense to supply raw registers.  */
-  gdb_assert (nr >= 0 && nr < NUM_REGS);
-  if (nr >= TS2_IMAP0_REGNUM
-      && nr < TS2_IMAP0_REGNUM + NR_IMAP_REGS)
-    return nr - TS2_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM;
-  if (nr == TS2_DMAP_REGNUM)
-    return nr - TS2_DMAP_REGNUM + SIM_D10V_TS2_DMAP_REGNUM;
-  if (nr >= TS2_A0_REGNUM
-      && nr < TS2_A0_REGNUM + NR_A_REGS)
-    return nr - TS2_A0_REGNUM + SIM_D10V_A0_REGNUM;
-  return nr;
-}
-
-static int
-d10v_ts3_register_sim_regno (int nr)
-{
-  /* Only makes sense to supply raw registers.  */
-  gdb_assert (nr >= 0 && nr < NUM_REGS);
-  if (nr >= TS3_IMAP0_REGNUM
-      && nr < TS3_IMAP0_REGNUM + NR_IMAP_REGS)
-    return nr - TS3_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM;
-  if (nr >= TS3_DMAP0_REGNUM
-      && nr < TS3_DMAP0_REGNUM + TS3_NR_DMAP_REGS)
-    return nr - TS3_DMAP0_REGNUM + SIM_D10V_DMAP0_REGNUM;
-  if (nr >= TS3_A0_REGNUM
-      && nr < TS3_A0_REGNUM + NR_A_REGS)
-    return nr - TS3_A0_REGNUM + SIM_D10V_A0_REGNUM;
-  return nr;
-}
-
-/* Return the GDB type object for the "standard" data type
-   of data in register N.  */
-
-static struct type *
-d10v_register_type (struct gdbarch *gdbarch, int reg_nr)
-{
-  if (reg_nr == D10V_PC_REGNUM)
-    return builtin_type (gdbarch)->builtin_func_ptr;
-  if (reg_nr == D10V_SP_REGNUM || reg_nr == D10V_FP_REGNUM)
-    return builtin_type (gdbarch)->builtin_data_ptr;
-  else if (reg_nr >= a0_regnum (gdbarch)
-	   && reg_nr < (a0_regnum (gdbarch) + NR_A_REGS))
-    return builtin_type_int64;
-  else
-    return builtin_type_int16;
-}
-
-static int
-d10v_iaddr_p (CORE_ADDR x)
-{
-  return (((x) & 0x3000000) == IMEM_START);
-}
-
-static CORE_ADDR
-d10v_make_daddr (CORE_ADDR x)
-{
-  return ((x) | DMEM_START);
-}
-
-static CORE_ADDR
-d10v_make_iaddr (CORE_ADDR x)
-{
-  if (d10v_iaddr_p (x))
-    return x;	/* Idempotency -- x is already in the IMEM space.  */
-  else
-    return (((x) << 2) | IMEM_START);
-}
-
-static CORE_ADDR
-d10v_convert_iaddr_to_raw (CORE_ADDR x)
-{
-  return (((x) >> 2) & 0xffff);
-}
-
-static CORE_ADDR
-d10v_convert_daddr_to_raw (CORE_ADDR x)
-{
-  return ((x) & 0xffff);
-}
-
-static void
-d10v_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
-{
-  /* Is it a code address?  */
-  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
-      || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
-    {
-      store_unsigned_integer (buf, TYPE_LENGTH (type), 
-                              d10v_convert_iaddr_to_raw (addr));
-    }
-  else
-    {
-      /* Strip off any upper segment bits.  */
-      store_unsigned_integer (buf, TYPE_LENGTH (type), 
-                              d10v_convert_daddr_to_raw (addr));
-    }
-}
-
-static CORE_ADDR
-d10v_pointer_to_address (struct type *type, const void *buf)
-{
-  CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
-  /* Is it a code address?  */
-  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
-      || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
-      || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
-    return d10v_make_iaddr (addr);
-  else
-    return d10v_make_daddr (addr);
-}
-
-/* Don't do anything if we have an integer, this way users can type 'x
-   <addr>' w/o having gdb outsmart them.  The internal gdb conversions
-   to the correct space are taken care of in the pointer_to_address
-   function.  If we don't do this, 'x $fp' wouldn't work.  */
-static CORE_ADDR
-d10v_integer_to_address (struct type *type, void *buf)
-{
-  LONGEST val;
-  val = unpack_long (type, buf);
-  return val;
-}
-
-/* Handle the d10v's return_value convention.  */
-
-static enum return_value_convention
-d10v_return_value (struct gdbarch *gdbarch, struct type *valtype,
-		   struct regcache *regcache, void *readbuf,
-		   const void *writebuf)
-{
-  if (TYPE_LENGTH (valtype) > 8)
-    /* Anything larger than 8 bytes (4 registers) goes on the stack.  */
-    return RETURN_VALUE_STRUCT_CONVENTION;
-  if (TYPE_LENGTH (valtype) == 5
-      || TYPE_LENGTH (valtype) == 6)
-    /* Anything 5 or 6 bytes in size goes in memory.  Contents don't
-       appear to matter.  Note that 7 and 8 byte objects do end up in
-       registers!  */
-    return RETURN_VALUE_STRUCT_CONVENTION;
-  if (TYPE_LENGTH (valtype) == 1)
-    {
-      /* All single byte values go in a register stored right-aligned.
-         Note: 2 byte integer values are handled further down.  */
-      if (readbuf)
-	{
-	  /* Since TYPE is smaller than the register, there isn't a
-             sign extension problem.  Let the extraction truncate the
-             register value.  */
-	  ULONGEST regval;
-	  regcache_cooked_read_unsigned (regcache, R0_REGNUM,
-					 &regval);
-	  store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), regval);
-
-	}
-      if (writebuf)
-	{
-	  ULONGEST regval;
-	  if (TYPE_CODE (valtype) == TYPE_CODE_INT)
-	    /* Some sort of integer value stored in R0.  Use
-	       unpack_long since that should handle any required sign
-	       extension.  */
-	    regval = unpack_long (valtype, writebuf);
-	  else
-	    /* Some other type.  Don't sign-extend the value when
-               storing it in the register.  */
-	    regval = extract_unsigned_integer (writebuf, 1);
-	  regcache_cooked_write_unsigned (regcache, R0_REGNUM, regval);
-	}
-      return RETURN_VALUE_REGISTER_CONVENTION;
-    }
-  if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
-       || TYPE_CODE (valtype) == TYPE_CODE_UNION)
-      && TYPE_NFIELDS (valtype) > 1
-      && TYPE_FIELD_BITPOS (valtype, 1) == 8)
-    /* If a composite is 8 bit aligned (determined by looking at the
-       start address of the second field), put it in memory.  */
-    return RETURN_VALUE_STRUCT_CONVENTION;
-  /* Assume it is in registers.  */
-  if (writebuf || readbuf)
-    {
-      int reg;
-      /* Per above, the value is never more than 8 bytes long.  */
-      gdb_assert (TYPE_LENGTH (valtype) <= 8);
-      /* Xfer 2 bytes at a time.  */
-      for (reg = 0; (reg * 2) + 1 < TYPE_LENGTH (valtype); reg++)
-	{
-	  if (readbuf)
-	    regcache_cooked_read (regcache, R0_REGNUM + reg,
-				  (bfd_byte *) readbuf + reg * 2);
-	  if (writebuf)
-	    regcache_cooked_write (regcache, R0_REGNUM + reg,
-				   (bfd_byte *) writebuf + reg * 2);
-	}
-      /* Any trailing byte ends up _left_ aligned.  */
-      if ((reg * 2) < TYPE_LENGTH (valtype))
-	{
-	  if (readbuf)
-	    regcache_cooked_read_part (regcache, R0_REGNUM + reg,
-				       0, 1, (bfd_byte *) readbuf + reg * 2);
-	  if (writebuf)
-	    regcache_cooked_write_part (regcache, R0_REGNUM + reg,
-					0, 1, (bfd_byte *) writebuf + reg * 2);
-	}
-    }
-  return RETURN_VALUE_REGISTER_CONVENTION;
-}
-
-static int
-check_prologue (unsigned short op)
-{
-  /* st  rn, @-sp */
-  if ((op & 0x7E1F) == 0x6C1F)
-    return 1;
-
-  /* st2w  rn, @-sp */
-  if ((op & 0x7E3F) == 0x6E1F)
-    return 1;
-
-  /* subi  sp, n */
-  if ((op & 0x7FE1) == 0x01E1)
-    return 1;
-
-  /* mv  r11, sp */
-  if (op == 0x417E)
-    return 1;
-
-  /* nop */
-  if (op == 0x5E00)
-    return 1;
-
-  /* st  rn, @sp */
-  if ((op & 0x7E1F) == 0x681E)
-    return 1;
-
-  /* st2w  rn, @sp */
-  if ((op & 0x7E3F) == 0x3A1E)
-    return 1;
-
-  return 0;
-}
-
-static CORE_ADDR
-d10v_skip_prologue (CORE_ADDR pc)
-{
-  unsigned long op;
-  unsigned short op1, op2;
-  CORE_ADDR func_addr, func_end;
-  struct symtab_and_line sal;
-
-  /* If we have line debugging information, then the end of the prologue 
-     should be the first assembly instruction of the first source line.  */
-  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
-    {
-      sal = find_pc_line (func_addr, 0);
-      if (sal.end && sal.end < func_end)
-	return sal.end;
-    }
-
-  if (target_read_memory (pc, (char *) &op, 4))
-    return pc;			/* Can't access it -- assume no prologue.  */
-
-  while (1)
-    {
-      op = (unsigned long) read_memory_integer (pc, 4);
-      if ((op & 0xC0000000) == 0xC0000000)
-	{
-	  /* long instruction */
-	  if (((op & 0x3FFF0000) != 0x01FF0000) &&	/* add3 sp,sp,n */
-	      ((op & 0x3F0F0000) != 0x340F0000) &&	/* st  rn, @(offset,sp) */
-	      ((op & 0x3F1F0000) != 0x350F0000))	/* st2w  rn, @(offset,sp) */
-	    break;
-	}
-      else
-	{
-	  /* short instructions */
-	  if ((op & 0xC0000000) == 0x80000000)
-	    {
-	      op2 = (op & 0x3FFF8000) >> 15;
-	      op1 = op & 0x7FFF;
-	    }
-	  else
-	    {
-	      op1 = (op & 0x3FFF8000) >> 15;
-	      op2 = op & 0x7FFF;
-	    }
-	  if (check_prologue (op1))
-	    {
-	      if (!check_prologue (op2))
-		{
-		  /* If the previous opcode was really part of the
-		     prologue and not just a NOP, then we want to
-		     break after both instructions.  */
-		  if (op1 != 0x5E00)
-		    pc += 4;
-		  break;
-		}
-	    }
-	  else
-	    break;
-	}
-      pc += 4;
-    }
-  return pc;
-}
-
-struct d10v_unwind_cache
-{
-  /* The previous frame's inner most stack address.  Used as this
-     frame ID's stack_addr.  */
-  CORE_ADDR prev_sp;
-  /* The frame's base, optionally used by the high-level debug info.  */
-  CORE_ADDR base;
-  int size;
-  /* How far the SP and r11 (FP) have been offset from the start of
-     the stack frame (as defined by the previous frame's stack
-     pointer).  */
-  LONGEST sp_offset;
-  LONGEST r11_offset;
-  int uses_frame;
-  /* Table indicating the location of each and every register.  */
-  struct trad_frame_saved_reg *saved_regs;
-};
-
-static int
-prologue_find_regs (struct d10v_unwind_cache *info, unsigned short op,
-		    CORE_ADDR addr)
-{
-  int n;
-
-  /* st  rn, @-sp */
-  if ((op & 0x7E1F) == 0x6C1F)
-    {
-      n = (op & 0x1E0) >> 5;
-      info->sp_offset -= 2;
-      info->saved_regs[n].addr = info->sp_offset;
-      return 1;
-    }
-
-  /* st2w  rn, @-sp */
-  else if ((op & 0x7E3F) == 0x6E1F)
-    {
-      n = (op & 0x1E0) >> 5;
-      info->sp_offset -= 4;
-      info->saved_regs[n + 0].addr = info->sp_offset + 0;
-      info->saved_regs[n + 1].addr = info->sp_offset + 2;
-      return 1;
-    }
-
-  /* subi  sp, n */
-  if ((op & 0x7FE1) == 0x01E1)
-    {
-      n = (op & 0x1E) >> 1;
-      if (n == 0)
-	n = 16;
-      info->sp_offset -= n;
-      return 1;
-    }
-
-  /* mv  r11, sp */
-  if (op == 0x417E)
-    {
-      info->uses_frame = 1;
-      info->r11_offset = info->sp_offset;
-      return 1;
-    }
-
-  /* st  rn, @r11 */
-  if ((op & 0x7E1F) == 0x6816)
-    {
-      n = (op & 0x1E0) >> 5;
-      info->saved_regs[n].addr = info->r11_offset;
-      return 1;
-    }
-
-  /* nop */
-  if (op == 0x5E00)
-    return 1;
-
-  /* st  rn, @sp */
-  if ((op & 0x7E1F) == 0x681E)
-    {
-      n = (op & 0x1E0) >> 5;
-      info->saved_regs[n].addr = info->sp_offset;
-      return 1;
-    }
-
-  /* st2w  rn, @sp */
-  if ((op & 0x7E3F) == 0x3A1E)
-    {
-      n = (op & 0x1E0) >> 5;
-      info->saved_regs[n + 0].addr = info->sp_offset + 0;
-      info->saved_regs[n + 1].addr = info->sp_offset + 2;
-      return 1;
-    }
-
-  return 0;
-}
-
-/* Put here the code to store, into fi->saved_regs, the addresses of
-   the saved registers of frame described by FRAME_INFO.  This
-   includes special registers such as pc and fp saved in special ways
-   in the stack frame.  sp is even more special: the address we return
-   for it IS the sp for the next frame.  */
-
-static struct d10v_unwind_cache *
-d10v_frame_unwind_cache (struct frame_info *next_frame,
-			 void **this_prologue_cache)
-{
-  struct gdbarch *gdbarch = get_frame_arch (next_frame);
-  CORE_ADDR pc;
-  ULONGEST prev_sp;
-  ULONGEST this_base;
-  unsigned long op;
-  unsigned short op1, op2;
-  int i;
-  struct d10v_unwind_cache *info;
-
-  if ((*this_prologue_cache))
-    return (*this_prologue_cache);
-
-  info = FRAME_OBSTACK_ZALLOC (struct d10v_unwind_cache);
-  (*this_prologue_cache) = info;
-  info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
-
-  info->size = 0;
-  info->sp_offset = 0;
-
-  info->uses_frame = 0;
-  for (pc = frame_func_unwind (next_frame);
-       pc > 0 && pc < frame_pc_unwind (next_frame);
-       pc += 4)
-    {
-      op = get_frame_memory_unsigned (next_frame, pc, 4);
-      if ((op & 0xC0000000) == 0xC0000000)
-	{
-	  /* long instruction */
-	  if ((op & 0x3FFF0000) == 0x01FF0000)
-	    {
-	      /* add3 sp,sp,n */
-	      short n = op & 0xFFFF;
-	      info->sp_offset += n;
-	    }
-	  else if ((op & 0x3F0F0000) == 0x340F0000)
-	    {
-	      /* st  rn, @(offset,sp) */
-	      short offset = op & 0xFFFF;
-	      short n = (op >> 20) & 0xF;
-	      info->saved_regs[n].addr = info->sp_offset + offset;
-	    }
-	  else if ((op & 0x3F1F0000) == 0x350F0000)
-	    {
-	      /* st2w  rn, @(offset,sp) */
-	      short offset = op & 0xFFFF;
-	      short n = (op >> 20) & 0xF;
-	      info->saved_regs[n + 0].addr = info->sp_offset + offset + 0;
-	      info->saved_regs[n + 1].addr = info->sp_offset + offset + 2;
-	    }
-	  else
-	    break;
-	}
-      else
-	{
-	  /* short instructions */
-	  if ((op & 0xC0000000) == 0x80000000)
-	    {
-	      op2 = (op & 0x3FFF8000) >> 15;
-	      op1 = op & 0x7FFF;
-	    }
-	  else
-	    {
-	      op1 = (op & 0x3FFF8000) >> 15;
-	      op2 = op & 0x7FFF;
-	    }
-	  if (!prologue_find_regs (info, op1, pc) 
-	      || !prologue_find_regs (info, op2, pc))
-	    break;
-	}
-    }
-
-  info->size = -info->sp_offset;
-
-  /* Compute the previous frame's stack pointer (which is also the
-     frame's ID's stack address), and this frame's base pointer.  */
-  if (info->uses_frame)
-    {
-      /* The SP was moved to the FP.  This indicates that a new frame
-         was created.  Get THIS frame's FP value by unwinding it from
-         the next frame.  */
-      frame_unwind_unsigned_register (next_frame, D10V_FP_REGNUM, &this_base);
-      /* The FP points at the last saved register.  Adjust the FP back
-         to before the first saved register giving the SP.  */
-      prev_sp = this_base + info->size;
-    }
-  else
-    {
-      /* Assume that the FP is this frame's SP but with that pushed
-         stack space added back.  */
-      frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &this_base);
-      prev_sp = this_base + info->size;
-    }
-
-  /* Convert that SP/BASE into real addresses.  */
-  info->prev_sp =  d10v_make_daddr (prev_sp);
-  info->base = d10v_make_daddr (this_base);
-
-  /* Adjust all the saved registers so that they contain addresses and
-     not offsets.  */
-  for (i = 0; i < NUM_REGS - 1; i++)
-    if (trad_frame_addr_p (info->saved_regs, i))
-      {
-	info->saved_regs[i].addr = (info->prev_sp + info->saved_regs[i].addr);
-      }
-
-  /* The call instruction moves the caller's PC in the callee's LR.
-     Since this is an unwind, do the reverse.  Copy the location of LR
-     into PC (the address / regnum) so that a request for PC will be
-     converted into a request for the LR.  */
-  info->saved_regs[D10V_PC_REGNUM] = info->saved_regs[LR_REGNUM];
-
-  /* The previous frame's SP needed to be computed.  Save the computed
-     value.  */
-  trad_frame_set_value (info->saved_regs, D10V_SP_REGNUM,
-			d10v_make_daddr (prev_sp));
-
-  return info;
-}
-
-static void
-d10v_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
-			   struct frame_info *frame, int regnum, int all)
-{
-  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  if (regnum >= 0)
-    {
-      default_print_registers_info (gdbarch, file, frame, regnum, all);
-      return;
-    }
-
-  {
-    ULONGEST pc, psw, rpt_s, rpt_e, rpt_c;
-    pc = get_frame_register_unsigned (frame, D10V_PC_REGNUM);
-    psw = get_frame_register_unsigned (frame, PSW_REGNUM);
-    rpt_s = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_s", -1));
-    rpt_e = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_e", -1));
-    rpt_c = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_c", -1));
-    fprintf_filtered (file, "PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n",
-		     (long) pc, (long) d10v_make_iaddr (pc), (long) psw,
-		     (long) rpt_s, (long) rpt_e, (long) rpt_c);
-  }
-
-  {
-    int group;
-    for (group = 0; group < 16; group += 8)
-      {
-	int r;
-	fprintf_filtered (file, "R%d-R%-2d", group, group + 7);
-	for (r = group; r < group + 8; r++)
-	  {
-	    ULONGEST tmp;
-	    tmp = get_frame_register_unsigned (frame, r);
-	    fprintf_filtered (file, " %04lx", (long) tmp);
-	  }
-	fprintf_filtered (file, "\n");
-      }
-  }
-
-  /* Note: The IMAP/DMAP registers don't participate in function
-     calls.  Don't bother trying to unwind them.  */
-
-  {
-    int a;
-    for (a = 0; a < NR_IMAP_REGS; a++)
-      {
-	if (a > 0)
-	  fprintf_filtered (file, "    ");
-	fprintf_filtered (file, "IMAP%d %04lx", a,
-			  tdep->imap_register (current_regcache, a));
-      }
-    if (nr_dmap_regs (gdbarch) == 1)
-      /* Registers DMAP0 and DMAP1 are constant.  Just return dmap2.  */
-      fprintf_filtered (file, "    DMAP %04lx\n",
-			tdep->dmap_register (current_regcache, 2));
-    else
-      {
-	for (a = 0; a < nr_dmap_regs (gdbarch); a++)
-	  {
-	    fprintf_filtered (file, "    DMAP%d %04lx", a,
-			      tdep->dmap_register (current_regcache, a));
-	  }
-	fprintf_filtered (file, "\n");
-      }
-  }
-
-  {
-    char num[MAX_REGISTER_SIZE];
-    int a;
-    fprintf_filtered (file, "A0-A%d", NR_A_REGS - 1);
-    for (a = a0_regnum (gdbarch); a < a0_regnum (gdbarch) + NR_A_REGS; a++)
-      {
-	int i;
-	fprintf_filtered (file, "  ");
-	get_frame_register (frame, a, num);
-	for (i = 0; i < register_size (gdbarch, a); i++)
-	  {
-	    fprintf_filtered (file, "%02x", (num[i] & 0xff));
-	  }
-      }
-  }
-  fprintf_filtered (file, "\n");
-}
-
-static void
-show_regs (char *args, int from_tty)
-{
-  d10v_print_registers_info (current_gdbarch, gdb_stdout,
-			     get_current_frame (), -1, 1);
-}
-
-static CORE_ADDR
-d10v_read_pc (ptid_t ptid)
-{
-  ptid_t save_ptid;
-  CORE_ADDR pc;
-  CORE_ADDR retval;
-
-  save_ptid = inferior_ptid;
-  inferior_ptid = ptid;
-  pc = (int) read_register (D10V_PC_REGNUM);
-  inferior_ptid = save_ptid;
-  retval = d10v_make_iaddr (pc);
-  return retval;
-}
-
-static void
-d10v_write_pc (CORE_ADDR val, ptid_t ptid)
-{
-  ptid_t save_ptid;
-
-  save_ptid = inferior_ptid;
-  inferior_ptid = ptid;
-  write_register (D10V_PC_REGNUM, d10v_convert_iaddr_to_raw (val));
-  inferior_ptid = save_ptid;
-}
-
-static CORE_ADDR
-d10v_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  ULONGEST sp;
-  frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &sp);
-  return d10v_make_daddr (sp);
-}
-
-/* When arguments must be pushed onto the stack, they go on in reverse
-   order.  The below implements a FILO (stack) to do this.  */
-
-struct stack_item
-{
-  int len;
-  struct stack_item *prev;
-  void *data;
-};
-
-static struct stack_item *push_stack_item (struct stack_item *prev,
-					   void *contents, int len);
-static struct stack_item *
-push_stack_item (struct stack_item *prev, void *contents, int len)
-{
-  struct stack_item *si;
-  si = xmalloc (sizeof (struct stack_item));
-  si->data = xmalloc (len);
-  si->len = len;
-  si->prev = prev;
-  memcpy (si->data, contents, len);
-  return si;
-}
-
-static struct stack_item *pop_stack_item (struct stack_item *si);
-static struct stack_item *
-pop_stack_item (struct stack_item *si)
-{
-  struct stack_item *dead = si;
-  si = si->prev;
-  xfree (dead->data);
-  xfree (dead);
-  return si;
-}
-
-
-static CORE_ADDR
-d10v_push_dummy_code (struct gdbarch *gdbarch,
-		      CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
-		      struct value **args, int nargs,
-		      struct type *value_type,
-		      CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
-{
-  /* Allocate space sufficient for a breakpoint.  */
-  sp = (sp - 4) & ~3;
-  /* Store the address of that breakpoint taking care to first convert
-     it into a code (IADDR) address from a stack (DADDR) address.
-     This of course assumes that the two virtual addresses map onto
-     the same real address.  */
-  (*bp_addr) = d10v_make_iaddr (d10v_convert_iaddr_to_raw (sp));
-  /* d10v always starts the call at the callee's entry point.  */
-  (*real_pc) = funaddr;
-  return sp;
-}
-
-static CORE_ADDR
-d10v_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
-		      struct regcache *regcache, CORE_ADDR bp_addr,
-		      int nargs, struct value **args, CORE_ADDR sp, 
-		      int struct_return, CORE_ADDR struct_addr)
-{
-  int i;
-  int regnum = ARG1_REGNUM;
-  struct stack_item *si = NULL;
-  long val;
-
-  /* Set the return address.  For the d10v, the return breakpoint is
-     always at BP_ADDR.  */
-  regcache_cooked_write_unsigned (regcache, LR_REGNUM,
-				  d10v_convert_iaddr_to_raw (bp_addr));
-
-  /* If STRUCT_RETURN is true, then the struct return address (in
-     STRUCT_ADDR) will consume the first argument-passing register.
-     Both adjust the register count and store that value.  */
-  if (struct_return)
-    {
-      regcache_cooked_write_unsigned (regcache, regnum, struct_addr);
-      regnum++;
-    }
-
-  /* Fill in registers and arg lists */
-  for (i = 0; i < nargs; i++)
-    {
-      struct value *arg = args[i];
-      struct type *type = check_typedef (VALUE_TYPE (arg));
-      char *contents = VALUE_CONTENTS (arg);
-      int len = TYPE_LENGTH (type);
-      int aligned_regnum = (regnum + 1) & ~1;
-
-      /* printf ("push: type=%d len=%d\n", TYPE_CODE (type), len); */
-      if (len <= 2 && regnum <= ARGN_REGNUM)
-	/* fits in a single register, do not align */
-	{
-	  val = extract_unsigned_integer (contents, len);
-	  regcache_cooked_write_unsigned (regcache, regnum++, val);
-	}
-      else if (len <= (ARGN_REGNUM - aligned_regnum + 1) * 2)
-	/* value fits in remaining registers, store keeping left
-	   aligned */
-	{
-	  int b;
-	  regnum = aligned_regnum;
-	  for (b = 0; b < (len & ~1); b += 2)
-	    {
-	      val = extract_unsigned_integer (&contents[b], 2);
-	      regcache_cooked_write_unsigned (regcache, regnum++, val);
-	    }
-	  if (b < len)
-	    {
-	      val = extract_unsigned_integer (&contents[b], 1);
-	      regcache_cooked_write_unsigned (regcache, regnum++, (val << 8));
-	    }
-	}
-      else
-	{
-	  /* arg will go onto stack */
-	  regnum = ARGN_REGNUM + 1;
-	  si = push_stack_item (si, contents, len);
-	}
-    }
-
-  while (si)
-    {
-      sp = (sp - si->len) & ~1;
-      write_memory (sp, si->data, si->len);
-      si = pop_stack_item (si);
-    }
-
-  /* Finally, update the SP register.  */
-  regcache_cooked_write_unsigned (regcache, D10V_SP_REGNUM,
-				  d10v_convert_daddr_to_raw (sp));
-
-  return sp;
-}
-
-/* Translate a GDB virtual ADDR/LEN into a format the remote target
-   understands.  Returns number of bytes that can be transfered
-   starting at TARG_ADDR.  Return ZERO if no bytes can be transfered
-   (segmentation fault).  Since the simulator knows all about how the
-   VM system works, we just call that to do the translation.  */
-
-static void
-remote_d10v_translate_xfer_address (struct gdbarch *gdbarch,
-				    struct regcache *regcache,
-				    CORE_ADDR memaddr, int nr_bytes,
-				    CORE_ADDR *targ_addr, int *targ_len)
-{
-  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  long out_addr;
-  long out_len;
-  out_len = sim_d10v_translate_addr (memaddr, nr_bytes, &out_addr, regcache,
-				     tdep->dmap_register, tdep->imap_register);
-  *targ_addr = out_addr;
-  *targ_len = out_len;
-}
-
-
-/* The following code implements access to, and display of, the D10V's
-   instruction trace buffer.  The buffer consists of 64K or more
-   4-byte words of data, of which each words includes an 8-bit count,
-   an 8-bit segment number, and a 16-bit instruction address.
-
-   In theory, the trace buffer is continuously capturing instruction
-   data that the CPU presents on its "debug bus", but in practice, the
-   ROMified GDB stub only enables tracing when it continues or steps
-   the program, and stops tracing when the program stops; so it
-   actually works for GDB to read the buffer counter out of memory and
-   then read each trace word.  The counter records where the tracing
-   stops, but there is no record of where it started, so we remember
-   the PC when we resumed and then search backwards in the trace
-   buffer for a word that includes that address.  This is not perfect,
-   because you will miss trace data if the resumption PC is the target
-   of a branch.  (The value of the buffer counter is semi-random, any
-   trace data from a previous program stop is gone.)  */
-
-/* The address of the last word recorded in the trace buffer.  */
-
-#define DBBC_ADDR (0xd80000)
-
-/* The base of the trace buffer, at least for the "Board_0".  */
-
-#define TRACE_BUFFER_BASE (0xf40000)
-
-static void trace_command (char *, int);
-
-static void untrace_command (char *, int);
-
-static void trace_info (char *, int);
-
-static void tdisassemble_command (char *, int);
-
-static void display_trace (int, int);
-
-/* True when instruction traces are being collected.  */
-
-static int tracing;
-
-/* Remembered PC.  */
-
-static CORE_ADDR last_pc;
-
-/* True when trace output should be displayed whenever program stops.  */
-
-static int trace_display;
-
-/* True when trace listing should include source lines.  */
-
-static int default_trace_show_source = 1;
-
-struct trace_buffer
-  {
-    int size;
-    short *counts;
-    CORE_ADDR *addrs;
-  }
-trace_data;
-
-static void
-trace_command (char *args, int from_tty)
-{
-  /* Clear the host-side trace buffer, allocating space if needed.  */
-  trace_data.size = 0;
-  if (trace_data.counts == NULL)
-    trace_data.counts = XCALLOC (65536, short);
-  if (trace_data.addrs == NULL)
-    trace_data.addrs = XCALLOC (65536, CORE_ADDR);
-
-  tracing = 1;
-
-  printf_filtered ("Tracing is now on.\n");
-}
-
-static void
-untrace_command (char *args, int from_tty)
-{
-  tracing = 0;
-
-  printf_filtered ("Tracing is now off.\n");
-}
-
-static void
-trace_info (char *args, int from_tty)
-{
-  int i;
-
-  if (trace_data.size)
-    {
-      printf_filtered ("%d entries in trace buffer:\n", trace_data.size);
-
-      for (i = 0; i < trace_data.size; ++i)
-	{
-	  printf_filtered ("%d: %d instruction%s at 0x%s\n",
-			   i,
-			   trace_data.counts[i],
-			   (trace_data.counts[i] == 1 ? "" : "s"),
-			   paddr_nz (trace_data.addrs[i]));
-	}
-    }
-  else
-    printf_filtered ("No entries in trace buffer.\n");
-
-  printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off"));
-}
-
-static void
-d10v_eva_prepare_to_trace (void)
-{
-  if (!tracing)
-    return;
-
-  last_pc = read_register (D10V_PC_REGNUM);
-}
-
-/* Collect trace data from the target board and format it into a form
-   more useful for display.  */
-
-static void
-d10v_eva_get_trace_data (void)
-{
-  int count, i, j, oldsize;
-  int trace_addr, trace_seg, trace_cnt, next_cnt;
-  unsigned int last_trace, trace_word, next_word;
-  unsigned int *tmpspace;
-
-  if (!tracing)
-    return;
-
-  tmpspace = xmalloc (65536 * sizeof (unsigned int));
-
-  last_trace = read_memory_unsigned_integer (DBBC_ADDR, 2) << 2;
-
-  /* Collect buffer contents from the target, stopping when we reach
-     the word recorded when execution resumed.  */
-
-  count = 0;
-  while (last_trace > 0)
-    {
-      QUIT;
-      trace_word =
-	read_memory_unsigned_integer (TRACE_BUFFER_BASE + last_trace, 4);
-      trace_addr = trace_word & 0xffff;
-      last_trace -= 4;
-      /* Ignore an apparently nonsensical entry.  */
-      if (trace_addr == 0xffd5)
-	continue;
-      tmpspace[count++] = trace_word;
-      if (trace_addr == last_pc)
-	break;
-      if (count > 65535)
-	break;
-    }
-
-  /* Move the data to the host-side trace buffer, adjusting counts to
-     include the last instruction executed and transforming the address
-     into something that GDB likes.  */
-
-  for (i = 0; i < count; ++i)
-    {
-      trace_word = tmpspace[i];
-      next_word = ((i == 0) ? 0 : tmpspace[i - 1]);
-      trace_addr = trace_word & 0xffff;
-      next_cnt = (next_word >> 24) & 0xff;
-      j = trace_data.size + count - i - 1;
-      trace_data.addrs[j] = (trace_addr << 2) + 0x1000000;
-      trace_data.counts[j] = next_cnt + 1;
-    }
-
-  oldsize = trace_data.size;
-  trace_data.size += count;
-
-  xfree (tmpspace);
-
-  if (trace_display)
-    display_trace (oldsize, trace_data.size);
-}
-
-static void
-tdisassemble_command (char *arg, int from_tty)
-{
-  int i, count;
-  CORE_ADDR low, high;
-
-  if (!arg)
-    {
-      low = 0;
-      high = trace_data.size;
-    }
-  else
-    { 
-      char *space_index = strchr (arg, ' ');
-      if (space_index == NULL)
-	{
-	  low = parse_and_eval_address (arg);
-	  high = low + 5;
-	}
-      else
-	{
-	  /* Two arguments.  */
-	  *space_index = '\0';
-	  low = parse_and_eval_address (arg);
-	  high = parse_and_eval_address (space_index + 1);
-	  if (high < low)
-	    high = low;
-	}
-    }
-
-  printf_filtered ("Dump of trace from %s to %s:\n", 
-		   paddr_u (low), paddr_u (high));
-
-  display_trace (low, high);
-
-  printf_filtered ("End of trace dump.\n");
-  gdb_flush (gdb_stdout);
-}
-
-static void
-display_trace (int low, int high)
-{
-  int i, count, trace_show_source, first, suppress;
-  CORE_ADDR next_address;
-
-  trace_show_source = default_trace_show_source;
-  if (!have_full_symbols () && !have_partial_symbols ())
-    {
-      trace_show_source = 0;
-      printf_filtered ("No symbol table is loaded.  Use the \"file\" command.\n");
-      printf_filtered ("Trace will not display any source.\n");
-    }
-
-  first = 1;
-  suppress = 0;
-  for (i = low; i < high; ++i)
-    {
-      next_address = trace_data.addrs[i];
-      count = trace_data.counts[i];
-      while (count-- > 0)
-	{
-	  QUIT;
-	  if (trace_show_source)
-	    {
-	      struct symtab_and_line sal, sal_prev;
-
-	      sal_prev = find_pc_line (next_address - 4, 0);
-	      sal = find_pc_line (next_address, 0);
-
-	      if (sal.symtab)
-		{
-		  if (first || sal.line != sal_prev.line)
-		    print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
-		  suppress = 0;
-		}
-	      else
-		{
-		  if (!suppress)
-		    /* FIXME-32x64--assumes sal.pc fits in long.  */
-		    printf_filtered ("No source file for address %s.\n",
-				     hex_string ((unsigned long) sal.pc));
-		  suppress = 1;
-		}
-	    }
-	  first = 0;
-	  print_address (next_address, gdb_stdout);
-	  printf_filtered (":");
-	  printf_filtered ("\t");
-	  wrap_here ("    ");
-	  next_address += gdb_print_insn (next_address, gdb_stdout);
-	  printf_filtered ("\n");
-	  gdb_flush (gdb_stdout);
-	}
-    }
-}
-
-static CORE_ADDR
-d10v_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  ULONGEST pc;
-  frame_unwind_unsigned_register (next_frame, D10V_PC_REGNUM, &pc);
-  return d10v_make_iaddr (pc);
-}
-
-/* Given a GDB frame, determine the address of the calling function's
-   frame.  This will be used to create a new GDB frame struct.  */
-
-static void
-d10v_frame_this_id (struct frame_info *next_frame,
-		    void **this_prologue_cache,
-		    struct frame_id *this_id)
-{
-  struct d10v_unwind_cache *info
-    = d10v_frame_unwind_cache (next_frame, this_prologue_cache);
-  CORE_ADDR base;
-  CORE_ADDR func;
-  struct frame_id id;
-
-  /* The FUNC is easy.  */
-  func = frame_func_unwind (next_frame);
-
-  /* Hopefully the prologue analysis either correctly determined the
-     frame's base (which is the SP from the previous frame), or set
-     that base to "NULL".  */
-  base = info->prev_sp;
-  if (base == STACK_START || base == 0)
-    return;
-
-  id = frame_id_build (base, func);
-
-  (*this_id) = id;
-}
-
-static void
-d10v_frame_prev_register (struct frame_info *next_frame,
-			  void **this_prologue_cache,
-			  int regnum, int *optimizedp,
-			  enum lval_type *lvalp, CORE_ADDR *addrp,
-			  int *realnump, void *bufferp)
-{
-  struct d10v_unwind_cache *info
-    = d10v_frame_unwind_cache (next_frame, this_prologue_cache);
-  trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
-				optimizedp, lvalp, addrp, realnump, bufferp);
-}
-
-static const struct frame_unwind d10v_frame_unwind = {
-  NORMAL_FRAME,
-  d10v_frame_this_id,
-  d10v_frame_prev_register
-};
-
-static const struct frame_unwind *
-d10v_frame_sniffer (struct frame_info *next_frame)
-{
-  return &d10v_frame_unwind;
-}
-
-static CORE_ADDR
-d10v_frame_base_address (struct frame_info *next_frame, void **this_cache)
-{
-  struct d10v_unwind_cache *info
-    = d10v_frame_unwind_cache (next_frame, this_cache);
-  return info->base;
-}
-
-static const struct frame_base d10v_frame_base = {
-  &d10v_frame_unwind,
-  d10v_frame_base_address,
-  d10v_frame_base_address,
-  d10v_frame_base_address
-};
-
-/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
-   dummy frame.  The frame ID's base needs to match the TOS value
-   saved by save_dummy_frame_tos(), and the PC match the dummy frame's
-   breakpoint.  */
-
-static struct frame_id
-d10v_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  return frame_id_build (d10v_unwind_sp (gdbarch, next_frame),
-			 frame_pc_unwind (next_frame));
-}
-
-static gdbarch_init_ftype d10v_gdbarch_init;
-
-static struct gdbarch *
-d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
-{
-  struct gdbarch *gdbarch;
-  int d10v_num_regs;
-  struct gdbarch_tdep *tdep;
-  gdbarch_register_name_ftype *d10v_register_name;
-  gdbarch_register_sim_regno_ftype *d10v_register_sim_regno;
-
-  /* Find a candidate among the list of pre-declared architectures.  */
-  arches = gdbarch_list_lookup_by_info (arches, &info);
-  if (arches != NULL)
-    return arches->gdbarch;
-
-  /* None found, create a new architecture from the information
-     provided.  */
-  tdep = XMALLOC (struct gdbarch_tdep);
-  gdbarch = gdbarch_alloc (&info, tdep);
-
-  switch (info.bfd_arch_info->mach)
-    {
-    case bfd_mach_d10v_ts2:
-      d10v_num_regs = 37;
-      d10v_register_name = d10v_ts2_register_name;
-      d10v_register_sim_regno = d10v_ts2_register_sim_regno;
-      tdep->a0_regnum = TS2_A0_REGNUM;
-      tdep->nr_dmap_regs = TS2_NR_DMAP_REGS;
-      tdep->dmap_register = d10v_ts2_dmap_register;
-      tdep->imap_register = d10v_ts2_imap_register;
-      break;
-    default:
-    case bfd_mach_d10v_ts3:
-      d10v_num_regs = 42;
-      d10v_register_name = d10v_ts3_register_name;
-      d10v_register_sim_regno = d10v_ts3_register_sim_regno;
-      tdep->a0_regnum = TS3_A0_REGNUM;
-      tdep->nr_dmap_regs = TS3_NR_DMAP_REGS;
-      tdep->dmap_register = d10v_ts3_dmap_register;
-      tdep->imap_register = d10v_ts3_imap_register;
-      break;
-    }
-
-  set_gdbarch_read_pc (gdbarch, d10v_read_pc);
-  set_gdbarch_write_pc (gdbarch, d10v_write_pc);
-  set_gdbarch_unwind_sp (gdbarch, d10v_unwind_sp);
-
-  set_gdbarch_num_regs (gdbarch, d10v_num_regs);
-  set_gdbarch_sp_regnum (gdbarch, D10V_SP_REGNUM);
-  set_gdbarch_register_name (gdbarch, d10v_register_name);
-  set_gdbarch_register_type (gdbarch, d10v_register_type);
-
-  set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-  set_gdbarch_addr_bit (gdbarch, 32);
-  set_gdbarch_address_to_pointer (gdbarch, d10v_address_to_pointer);
-  set_gdbarch_pointer_to_address (gdbarch, d10v_pointer_to_address);
-  set_gdbarch_integer_to_address (gdbarch, d10v_integer_to_address);
-  set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-  set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
-  set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-  set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
-  /* NOTE: The d10v as a 32 bit ``float'' and ``double''. ``long
-     double'' is 64 bits.  */
-  set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-  set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
-  set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
-  switch (info.byte_order)
-    {
-    case BFD_ENDIAN_BIG:
-      set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_big);
-      set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_big);
-      set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
-      break;
-    case BFD_ENDIAN_LITTLE:
-      set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little);
-      set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_little);
-      set_gdbarch_long_double_format (gdbarch, 
-				      &floatformat_ieee_double_little);
-      break;
-    default:
-      internal_error (__FILE__, __LINE__,
-		      "d10v_gdbarch_init: bad byte order for float format");
-    }
-
-  set_gdbarch_return_value (gdbarch, d10v_return_value);
-  set_gdbarch_push_dummy_code (gdbarch, d10v_push_dummy_code);
-  set_gdbarch_push_dummy_call (gdbarch, d10v_push_dummy_call);
-
-  set_gdbarch_skip_prologue (gdbarch, d10v_skip_prologue);
-  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
-  set_gdbarch_decr_pc_after_break (gdbarch, 4);
-  set_gdbarch_breakpoint_from_pc (gdbarch, d10v_breakpoint_from_pc);
-
-  set_gdbarch_remote_translate_xfer_address (gdbarch, 
-					     remote_d10v_translate_xfer_address);
-
-  set_gdbarch_frame_align (gdbarch, d10v_frame_align);
-
-  set_gdbarch_register_sim_regno (gdbarch, d10v_register_sim_regno);
-
-  set_gdbarch_print_registers_info (gdbarch, d10v_print_registers_info);
-
-  frame_unwind_append_sniffer (gdbarch, d10v_frame_sniffer);
-  frame_base_set_default (gdbarch, &d10v_frame_base);
-
-  /* Methods for saving / extracting a dummy frame's ID.  The ID's
-     stack address must match the SP value returned by
-     PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
-  set_gdbarch_unwind_dummy_id (gdbarch, d10v_unwind_dummy_id);
-
-  /* Return the unwound PC value.  */
-  set_gdbarch_unwind_pc (gdbarch, d10v_unwind_pc);
-
-  set_gdbarch_print_insn (gdbarch, print_insn_d10v);
-
-  return gdbarch;
-}
-
-void
-_initialize_d10v_tdep (void)
-{
-  register_gdbarch_init (bfd_arch_d10v, d10v_gdbarch_init);
-
-  deprecated_target_resume_hook = d10v_eva_prepare_to_trace;
-  deprecated_target_wait_loop_hook = d10v_eva_get_trace_data;
-
-  deprecate_cmd (add_com ("regs", class_vars, show_regs, 
-			  "Print all registers"),
-		 "info registers");
-
-  add_com ("itrace", class_support, trace_command,
-	   "Enable tracing of instruction execution.");
-
-  add_com ("iuntrace", class_support, untrace_command,
-	   "Disable tracing of instruction execution.");
-
-  add_com ("itdisassemble", class_vars, tdisassemble_command,
-	   "Disassemble the trace buffer.\n\
-Two optional arguments specify a range of trace buffer entries\n\
-as reported by info trace (NOT addresses!).");
-
-  add_info ("itrace", trace_info,
-	    "Display info about the trace data buffer.");
-
-  add_setshow_boolean_cmd ("itracedisplay", no_class, &trace_display, "\
-Set automatic display of trace.", "\
-Show automatic display of trace.", "\
-Controls the display of d10v specific instruction trace information.", "\
-Automatic display of trace is %s.",
-			   NULL, NULL, &setlist, &showlist);
-  add_setshow_boolean_cmd ("itracesource", no_class,
-			   &default_trace_show_source, "\
-Set display of source code with trace.", "\
-Show display of source code with trace.", "\
-When on source code is included in the d10v instruction trace display.", "\
-Display of source code with trace is %s.",
-			   NULL, NULL, &setlist, &showlist);
-}
+// OBSOLETE /* Target-dependent code for Renesas D10V, for GDB.
+// OBSOLETE 
+// OBSOLETE    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
+// OBSOLETE    Foundation, Inc.
+// OBSOLETE 
+// OBSOLETE    This file is part of GDB.
+// OBSOLETE 
+// OBSOLETE    This program is free software; you can redistribute it and/or modify
+// OBSOLETE    it under the terms of the GNU General Public License as published by
+// OBSOLETE    the Free Software Foundation; either version 2 of the License, or
+// OBSOLETE    (at your option) any later version.
+// OBSOLETE 
+// OBSOLETE    This program is distributed in the hope that it will be useful,
+// OBSOLETE    but WITHOUT ANY WARRANTY; without even the implied warranty of
+// OBSOLETE    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// OBSOLETE    GNU General Public License for more details.
+// OBSOLETE 
+// OBSOLETE    You should have received a copy of the GNU General Public License
+// OBSOLETE    along with this program; if not, write to the Free Software
+// OBSOLETE    Foundation, Inc., 59 Temple Place - Suite 330,
+// OBSOLETE    Boston, MA 02111-1307, USA.  */
+// OBSOLETE 
+// OBSOLETE /*  Contributed by Martin Hunt, hunt@cygnus.com */
+// OBSOLETE 
+// OBSOLETE #include "defs.h"
+// OBSOLETE #include "frame.h"
+// OBSOLETE #include "frame-unwind.h"
+// OBSOLETE #include "frame-base.h"
+// OBSOLETE #include "symtab.h"
+// OBSOLETE #include "gdbtypes.h"
+// OBSOLETE #include "gdbcmd.h"
+// OBSOLETE #include "gdbcore.h"
+// OBSOLETE #include "gdb_string.h"
+// OBSOLETE #include "value.h"
+// OBSOLETE #include "inferior.h"
+// OBSOLETE #include "dis-asm.h"
+// OBSOLETE #include "symfile.h"
+// OBSOLETE #include "objfiles.h"
+// OBSOLETE #include "language.h"
+// OBSOLETE #include "arch-utils.h"
+// OBSOLETE #include "regcache.h"
+// OBSOLETE #include "remote.h"
+// OBSOLETE #include "floatformat.h"
+// OBSOLETE #include "gdb/sim-d10v.h"
+// OBSOLETE #include "sim-regno.h"
+// OBSOLETE #include "disasm.h"
+// OBSOLETE #include "trad-frame.h"
+// OBSOLETE 
+// OBSOLETE #include "gdb_assert.h"
+// OBSOLETE 
+// OBSOLETE struct gdbarch_tdep
+// OBSOLETE   {
+// OBSOLETE     int a0_regnum;
+// OBSOLETE     int nr_dmap_regs;
+// OBSOLETE     unsigned long (*dmap_register) (void *regcache, int nr);
+// OBSOLETE     unsigned long (*imap_register) (void *regcache, int nr);
+// OBSOLETE   };
+// OBSOLETE 
+// OBSOLETE /* These are the addresses the D10V-EVA board maps data and
+// OBSOLETE    instruction memory to.  */
+// OBSOLETE 
+// OBSOLETE enum memspace {
+// OBSOLETE   DMEM_START  = 0x2000000,
+// OBSOLETE   IMEM_START  = 0x1000000,
+// OBSOLETE   STACK_START = 0x200bffe
+// OBSOLETE };
+// OBSOLETE 
+// OBSOLETE /* d10v register names.  */
+// OBSOLETE 
+// OBSOLETE enum
+// OBSOLETE   {
+// OBSOLETE     R0_REGNUM = 0,
+// OBSOLETE     R3_REGNUM = 3,
+// OBSOLETE     D10V_FP_REGNUM = 11,
+// OBSOLETE     LR_REGNUM = 13,
+// OBSOLETE     D10V_SP_REGNUM = 15,
+// OBSOLETE     PSW_REGNUM = 16,
+// OBSOLETE     D10V_PC_REGNUM = 18,
+// OBSOLETE     NR_IMAP_REGS = 2,
+// OBSOLETE     NR_A_REGS = 2,
+// OBSOLETE     TS2_NUM_REGS = 37,
+// OBSOLETE     TS3_NUM_REGS = 42,
+// OBSOLETE     /* d10v calling convention.  */
+// OBSOLETE     ARG1_REGNUM = R0_REGNUM,
+// OBSOLETE     ARGN_REGNUM = R3_REGNUM
+// OBSOLETE   };
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE nr_dmap_regs (struct gdbarch *gdbarch)
+// OBSOLETE {
+// OBSOLETE   return gdbarch_tdep (gdbarch)->nr_dmap_regs;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE a0_regnum (struct gdbarch *gdbarch)
+// OBSOLETE {
+// OBSOLETE   return gdbarch_tdep (gdbarch)->a0_regnum;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Local functions */
+// OBSOLETE 
+// OBSOLETE extern void _initialize_d10v_tdep (void);
+// OBSOLETE 
+// OBSOLETE static void d10v_eva_prepare_to_trace (void);
+// OBSOLETE 
+// OBSOLETE static void d10v_eva_get_trace_data (void);
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
+// OBSOLETE {
+// OBSOLETE   /* Align to the size of an instruction (so that they can safely be
+// OBSOLETE      pushed onto the stack.  */
+// OBSOLETE   return sp & ~3;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static const unsigned char *
+// OBSOLETE d10v_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+// OBSOLETE {
+// OBSOLETE   static unsigned char breakpoint[] =
+// OBSOLETE   {0x2f, 0x90, 0x5e, 0x00};
+// OBSOLETE   *lenptr = sizeof (breakpoint);
+// OBSOLETE   return breakpoint;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Map the REG_NR onto an ascii name.  Return NULL or an empty string
+// OBSOLETE    when the reg_nr isn't valid.  */
+// OBSOLETE 
+// OBSOLETE enum ts2_regnums
+// OBSOLETE   {
+// OBSOLETE     TS2_IMAP0_REGNUM = 32,
+// OBSOLETE     TS2_DMAP_REGNUM = 34,
+// OBSOLETE     TS2_NR_DMAP_REGS = 1,
+// OBSOLETE     TS2_A0_REGNUM = 35
+// OBSOLETE   };
+// OBSOLETE 
+// OBSOLETE static const char *
+// OBSOLETE d10v_ts2_register_name (int reg_nr)
+// OBSOLETE {
+// OBSOLETE   static char *register_names[] =
+// OBSOLETE   {
+// OBSOLETE     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+// OBSOLETE     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+// OBSOLETE     "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
+// OBSOLETE     "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
+// OBSOLETE     "imap0", "imap1", "dmap", "a0", "a1"
+// OBSOLETE   };
+// OBSOLETE   if (reg_nr < 0)
+// OBSOLETE     return NULL;
+// OBSOLETE   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
+// OBSOLETE     return NULL;
+// OBSOLETE   return register_names[reg_nr];
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE enum ts3_regnums
+// OBSOLETE   {
+// OBSOLETE     TS3_IMAP0_REGNUM = 36,
+// OBSOLETE     TS3_DMAP0_REGNUM = 38,
+// OBSOLETE     TS3_NR_DMAP_REGS = 4,
+// OBSOLETE     TS3_A0_REGNUM = 32
+// OBSOLETE   };
+// OBSOLETE 
+// OBSOLETE static const char *
+// OBSOLETE d10v_ts3_register_name (int reg_nr)
+// OBSOLETE {
+// OBSOLETE   static char *register_names[] =
+// OBSOLETE   {
+// OBSOLETE     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+// OBSOLETE     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+// OBSOLETE     "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
+// OBSOLETE     "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
+// OBSOLETE     "a0", "a1",
+// OBSOLETE     "spi", "spu",
+// OBSOLETE     "imap0", "imap1",
+// OBSOLETE     "dmap0", "dmap1", "dmap2", "dmap3"
+// OBSOLETE   };
+// OBSOLETE   if (reg_nr < 0)
+// OBSOLETE     return NULL;
+// OBSOLETE   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
+// OBSOLETE     return NULL;
+// OBSOLETE   return register_names[reg_nr];
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Access the DMAP/IMAP registers in a target independent way.
+// OBSOLETE 
+// OBSOLETE    Divide the D10V's 64k data space into four 16k segments:
+// OBSOLETE    0x0000 -- 0x3fff, 0x4000 -- 0x7fff, 0x8000 -- 0xbfff, and 
+// OBSOLETE    0xc000 -- 0xffff.
+// OBSOLETE 
+// OBSOLETE    On the TS2, the first two segments (0x0000 -- 0x3fff, 0x4000 --
+// OBSOLETE    0x7fff) always map to the on-chip data RAM, and the fourth always
+// OBSOLETE    maps to I/O space.  The third (0x8000 - 0xbfff) can be mapped into
+// OBSOLETE    unified memory or instruction memory, under the control of the
+// OBSOLETE    single DMAP register.
+// OBSOLETE 
+// OBSOLETE    On the TS3, there are four DMAP registers, each of which controls
+// OBSOLETE    one of the segments.  */
+// OBSOLETE 
+// OBSOLETE static unsigned long
+// OBSOLETE d10v_ts2_dmap_register (void *regcache, int reg_nr)
+// OBSOLETE {
+// OBSOLETE   switch (reg_nr)
+// OBSOLETE     {
+// OBSOLETE     case 0:
+// OBSOLETE     case 1:
+// OBSOLETE       return 0x2000;
+// OBSOLETE     case 2:
+// OBSOLETE       {
+// OBSOLETE 	ULONGEST reg;
+// OBSOLETE 	regcache_cooked_read_unsigned (regcache, TS2_DMAP_REGNUM, &reg);
+// OBSOLETE 	return reg;
+// OBSOLETE       }
+// OBSOLETE     default:
+// OBSOLETE       return 0;
+// OBSOLETE     }
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static unsigned long
+// OBSOLETE d10v_ts3_dmap_register (void *regcache, int reg_nr)
+// OBSOLETE {
+// OBSOLETE   ULONGEST reg;
+// OBSOLETE   regcache_cooked_read_unsigned (regcache, TS3_DMAP0_REGNUM + reg_nr, &reg);
+// OBSOLETE   return reg;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static unsigned long
+// OBSOLETE d10v_ts2_imap_register (void *regcache, int reg_nr)
+// OBSOLETE {
+// OBSOLETE   ULONGEST reg;
+// OBSOLETE   regcache_cooked_read_unsigned (regcache, TS2_IMAP0_REGNUM + reg_nr, &reg);
+// OBSOLETE   return reg;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static unsigned long
+// OBSOLETE d10v_ts3_imap_register (void *regcache, int reg_nr)
+// OBSOLETE {
+// OBSOLETE   ULONGEST reg;
+// OBSOLETE   regcache_cooked_read_unsigned (regcache, TS3_IMAP0_REGNUM + reg_nr, &reg);
+// OBSOLETE   return reg;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* MAP GDB's internal register numbering (determined by the layout
+// OBSOLETE    from the DEPRECATED_REGISTER_BYTE array) onto the simulator's
+// OBSOLETE    register numbering.  */
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE d10v_ts2_register_sim_regno (int nr)
+// OBSOLETE {
+// OBSOLETE   /* Only makes sense to supply raw registers.  */
+// OBSOLETE   gdb_assert (nr >= 0 && nr < NUM_REGS);
+// OBSOLETE   if (nr >= TS2_IMAP0_REGNUM
+// OBSOLETE       && nr < TS2_IMAP0_REGNUM + NR_IMAP_REGS)
+// OBSOLETE     return nr - TS2_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM;
+// OBSOLETE   if (nr == TS2_DMAP_REGNUM)
+// OBSOLETE     return nr - TS2_DMAP_REGNUM + SIM_D10V_TS2_DMAP_REGNUM;
+// OBSOLETE   if (nr >= TS2_A0_REGNUM
+// OBSOLETE       && nr < TS2_A0_REGNUM + NR_A_REGS)
+// OBSOLETE     return nr - TS2_A0_REGNUM + SIM_D10V_A0_REGNUM;
+// OBSOLETE   return nr;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE d10v_ts3_register_sim_regno (int nr)
+// OBSOLETE {
+// OBSOLETE   /* Only makes sense to supply raw registers.  */
+// OBSOLETE   gdb_assert (nr >= 0 && nr < NUM_REGS);
+// OBSOLETE   if (nr >= TS3_IMAP0_REGNUM
+// OBSOLETE       && nr < TS3_IMAP0_REGNUM + NR_IMAP_REGS)
+// OBSOLETE     return nr - TS3_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM;
+// OBSOLETE   if (nr >= TS3_DMAP0_REGNUM
+// OBSOLETE       && nr < TS3_DMAP0_REGNUM + TS3_NR_DMAP_REGS)
+// OBSOLETE     return nr - TS3_DMAP0_REGNUM + SIM_D10V_DMAP0_REGNUM;
+// OBSOLETE   if (nr >= TS3_A0_REGNUM
+// OBSOLETE       && nr < TS3_A0_REGNUM + NR_A_REGS)
+// OBSOLETE     return nr - TS3_A0_REGNUM + SIM_D10V_A0_REGNUM;
+// OBSOLETE   return nr;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Return the GDB type object for the "standard" data type
+// OBSOLETE    of data in register N.  */
+// OBSOLETE 
+// OBSOLETE static struct type *
+// OBSOLETE d10v_register_type (struct gdbarch *gdbarch, int reg_nr)
+// OBSOLETE {
+// OBSOLETE   if (reg_nr == D10V_PC_REGNUM)
+// OBSOLETE     return builtin_type (gdbarch)->builtin_func_ptr;
+// OBSOLETE   if (reg_nr == D10V_SP_REGNUM || reg_nr == D10V_FP_REGNUM)
+// OBSOLETE     return builtin_type (gdbarch)->builtin_data_ptr;
+// OBSOLETE   else if (reg_nr >= a0_regnum (gdbarch)
+// OBSOLETE 	   && reg_nr < (a0_regnum (gdbarch) + NR_A_REGS))
+// OBSOLETE     return builtin_type_int64;
+// OBSOLETE   else
+// OBSOLETE     return builtin_type_int16;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE d10v_iaddr_p (CORE_ADDR x)
+// OBSOLETE {
+// OBSOLETE   return (((x) & 0x3000000) == IMEM_START);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_make_daddr (CORE_ADDR x)
+// OBSOLETE {
+// OBSOLETE   return ((x) | DMEM_START);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_make_iaddr (CORE_ADDR x)
+// OBSOLETE {
+// OBSOLETE   if (d10v_iaddr_p (x))
+// OBSOLETE     return x;	/* Idempotency -- x is already in the IMEM space.  */
+// OBSOLETE   else
+// OBSOLETE     return (((x) << 2) | IMEM_START);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_convert_iaddr_to_raw (CORE_ADDR x)
+// OBSOLETE {
+// OBSOLETE   return (((x) >> 2) & 0xffff);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_convert_daddr_to_raw (CORE_ADDR x)
+// OBSOLETE {
+// OBSOLETE   return ((x) & 0xffff);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE d10v_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
+// OBSOLETE {
+// OBSOLETE   /* Is it a code address?  */
+// OBSOLETE   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
+// OBSOLETE       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
+// OBSOLETE     {
+// OBSOLETE       store_unsigned_integer (buf, TYPE_LENGTH (type), 
+// OBSOLETE                               d10v_convert_iaddr_to_raw (addr));
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     {
+// OBSOLETE       /* Strip off any upper segment bits.  */
+// OBSOLETE       store_unsigned_integer (buf, TYPE_LENGTH (type), 
+// OBSOLETE                               d10v_convert_daddr_to_raw (addr));
+// OBSOLETE     }
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_pointer_to_address (struct type *type, const void *buf)
+// OBSOLETE {
+// OBSOLETE   CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
+// OBSOLETE   /* Is it a code address?  */
+// OBSOLETE   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
+// OBSOLETE       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
+// OBSOLETE       || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
+// OBSOLETE     return d10v_make_iaddr (addr);
+// OBSOLETE   else
+// OBSOLETE     return d10v_make_daddr (addr);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Don't do anything if we have an integer, this way users can type 'x
+// OBSOLETE    <addr>' w/o having gdb outsmart them.  The internal gdb conversions
+// OBSOLETE    to the correct space are taken care of in the pointer_to_address
+// OBSOLETE    function.  If we don't do this, 'x $fp' wouldn't work.  */
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_integer_to_address (struct type *type, void *buf)
+// OBSOLETE {
+// OBSOLETE   LONGEST val;
+// OBSOLETE   val = unpack_long (type, buf);
+// OBSOLETE   return val;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Handle the d10v's return_value convention.  */
+// OBSOLETE 
+// OBSOLETE static enum return_value_convention
+// OBSOLETE d10v_return_value (struct gdbarch *gdbarch, struct type *valtype,
+// OBSOLETE 		   struct regcache *regcache, void *readbuf,
+// OBSOLETE 		   const void *writebuf)
+// OBSOLETE {
+// OBSOLETE   if (TYPE_LENGTH (valtype) > 8)
+// OBSOLETE     /* Anything larger than 8 bytes (4 registers) goes on the stack.  */
+// OBSOLETE     return RETURN_VALUE_STRUCT_CONVENTION;
+// OBSOLETE   if (TYPE_LENGTH (valtype) == 5
+// OBSOLETE       || TYPE_LENGTH (valtype) == 6)
+// OBSOLETE     /* Anything 5 or 6 bytes in size goes in memory.  Contents don't
+// OBSOLETE        appear to matter.  Note that 7 and 8 byte objects do end up in
+// OBSOLETE        registers!  */
+// OBSOLETE     return RETURN_VALUE_STRUCT_CONVENTION;
+// OBSOLETE   if (TYPE_LENGTH (valtype) == 1)
+// OBSOLETE     {
+// OBSOLETE       /* All single byte values go in a register stored right-aligned.
+// OBSOLETE          Note: 2 byte integer values are handled further down.  */
+// OBSOLETE       if (readbuf)
+// OBSOLETE 	{
+// OBSOLETE 	  /* Since TYPE is smaller than the register, there isn't a
+// OBSOLETE              sign extension problem.  Let the extraction truncate the
+// OBSOLETE              register value.  */
+// OBSOLETE 	  ULONGEST regval;
+// OBSOLETE 	  regcache_cooked_read_unsigned (regcache, R0_REGNUM,
+// OBSOLETE 					 &regval);
+// OBSOLETE 	  store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), regval);
+// OBSOLETE 
+// OBSOLETE 	}
+// OBSOLETE       if (writebuf)
+// OBSOLETE 	{
+// OBSOLETE 	  ULONGEST regval;
+// OBSOLETE 	  if (TYPE_CODE (valtype) == TYPE_CODE_INT)
+// OBSOLETE 	    /* Some sort of integer value stored in R0.  Use
+// OBSOLETE 	       unpack_long since that should handle any required sign
+// OBSOLETE 	       extension.  */
+// OBSOLETE 	    regval = unpack_long (valtype, writebuf);
+// OBSOLETE 	  else
+// OBSOLETE 	    /* Some other type.  Don't sign-extend the value when
+// OBSOLETE                storing it in the register.  */
+// OBSOLETE 	    regval = extract_unsigned_integer (writebuf, 1);
+// OBSOLETE 	  regcache_cooked_write_unsigned (regcache, R0_REGNUM, regval);
+// OBSOLETE 	}
+// OBSOLETE       return RETURN_VALUE_REGISTER_CONVENTION;
+// OBSOLETE     }
+// OBSOLETE   if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
+// OBSOLETE        || TYPE_CODE (valtype) == TYPE_CODE_UNION)
+// OBSOLETE       && TYPE_NFIELDS (valtype) > 1
+// OBSOLETE       && TYPE_FIELD_BITPOS (valtype, 1) == 8)
+// OBSOLETE     /* If a composite is 8 bit aligned (determined by looking at the
+// OBSOLETE        start address of the second field), put it in memory.  */
+// OBSOLETE     return RETURN_VALUE_STRUCT_CONVENTION;
+// OBSOLETE   /* Assume it is in registers.  */
+// OBSOLETE   if (writebuf || readbuf)
+// OBSOLETE     {
+// OBSOLETE       int reg;
+// OBSOLETE       /* Per above, the value is never more than 8 bytes long.  */
+// OBSOLETE       gdb_assert (TYPE_LENGTH (valtype) <= 8);
+// OBSOLETE       /* Xfer 2 bytes at a time.  */
+// OBSOLETE       for (reg = 0; (reg * 2) + 1 < TYPE_LENGTH (valtype); reg++)
+// OBSOLETE 	{
+// OBSOLETE 	  if (readbuf)
+// OBSOLETE 	    regcache_cooked_read (regcache, R0_REGNUM + reg,
+// OBSOLETE 				  (bfd_byte *) readbuf + reg * 2);
+// OBSOLETE 	  if (writebuf)
+// OBSOLETE 	    regcache_cooked_write (regcache, R0_REGNUM + reg,
+// OBSOLETE 				   (bfd_byte *) writebuf + reg * 2);
+// OBSOLETE 	}
+// OBSOLETE       /* Any trailing byte ends up _left_ aligned.  */
+// OBSOLETE       if ((reg * 2) < TYPE_LENGTH (valtype))
+// OBSOLETE 	{
+// OBSOLETE 	  if (readbuf)
+// OBSOLETE 	    regcache_cooked_read_part (regcache, R0_REGNUM + reg,
+// OBSOLETE 				       0, 1, (bfd_byte *) readbuf + reg * 2);
+// OBSOLETE 	  if (writebuf)
+// OBSOLETE 	    regcache_cooked_write_part (regcache, R0_REGNUM + reg,
+// OBSOLETE 					0, 1, (bfd_byte *) writebuf + reg * 2);
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE   return RETURN_VALUE_REGISTER_CONVENTION;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE check_prologue (unsigned short op)
+// OBSOLETE {
+// OBSOLETE   /* st  rn, @-sp */
+// OBSOLETE   if ((op & 0x7E1F) == 0x6C1F)
+// OBSOLETE     return 1;
+// OBSOLETE 
+// OBSOLETE   /* st2w  rn, @-sp */
+// OBSOLETE   if ((op & 0x7E3F) == 0x6E1F)
+// OBSOLETE     return 1;
+// OBSOLETE 
+// OBSOLETE   /* subi  sp, n */
+// OBSOLETE   if ((op & 0x7FE1) == 0x01E1)
+// OBSOLETE     return 1;
+// OBSOLETE 
+// OBSOLETE   /* mv  r11, sp */
+// OBSOLETE   if (op == 0x417E)
+// OBSOLETE     return 1;
+// OBSOLETE 
+// OBSOLETE   /* nop */
+// OBSOLETE   if (op == 0x5E00)
+// OBSOLETE     return 1;
+// OBSOLETE 
+// OBSOLETE   /* st  rn, @sp */
+// OBSOLETE   if ((op & 0x7E1F) == 0x681E)
+// OBSOLETE     return 1;
+// OBSOLETE 
+// OBSOLETE   /* st2w  rn, @sp */
+// OBSOLETE   if ((op & 0x7E3F) == 0x3A1E)
+// OBSOLETE     return 1;
+// OBSOLETE 
+// OBSOLETE   return 0;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_skip_prologue (CORE_ADDR pc)
+// OBSOLETE {
+// OBSOLETE   unsigned long op;
+// OBSOLETE   unsigned short op1, op2;
+// OBSOLETE   CORE_ADDR func_addr, func_end;
+// OBSOLETE   struct symtab_and_line sal;
+// OBSOLETE 
+// OBSOLETE   /* If we have line debugging information, then the end of the prologue 
+// OBSOLETE      should be the first assembly instruction of the first source line.  */
+// OBSOLETE   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+// OBSOLETE     {
+// OBSOLETE       sal = find_pc_line (func_addr, 0);
+// OBSOLETE       if (sal.end && sal.end < func_end)
+// OBSOLETE 	return sal.end;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   if (target_read_memory (pc, (char *) &op, 4))
+// OBSOLETE     return pc;			/* Can't access it -- assume no prologue.  */
+// OBSOLETE 
+// OBSOLETE   while (1)
+// OBSOLETE     {
+// OBSOLETE       op = (unsigned long) read_memory_integer (pc, 4);
+// OBSOLETE       if ((op & 0xC0000000) == 0xC0000000)
+// OBSOLETE 	{
+// OBSOLETE 	  /* long instruction */
+// OBSOLETE 	  if (((op & 0x3FFF0000) != 0x01FF0000) &&	/* add3 sp,sp,n */
+// OBSOLETE 	      ((op & 0x3F0F0000) != 0x340F0000) &&	/* st  rn, @(offset,sp) */
+// OBSOLETE 	      ((op & 0x3F1F0000) != 0x350F0000))	/* st2w  rn, @(offset,sp) */
+// OBSOLETE 	    break;
+// OBSOLETE 	}
+// OBSOLETE       else
+// OBSOLETE 	{
+// OBSOLETE 	  /* short instructions */
+// OBSOLETE 	  if ((op & 0xC0000000) == 0x80000000)
+// OBSOLETE 	    {
+// OBSOLETE 	      op2 = (op & 0x3FFF8000) >> 15;
+// OBSOLETE 	      op1 = op & 0x7FFF;
+// OBSOLETE 	    }
+// OBSOLETE 	  else
+// OBSOLETE 	    {
+// OBSOLETE 	      op1 = (op & 0x3FFF8000) >> 15;
+// OBSOLETE 	      op2 = op & 0x7FFF;
+// OBSOLETE 	    }
+// OBSOLETE 	  if (check_prologue (op1))
+// OBSOLETE 	    {
+// OBSOLETE 	      if (!check_prologue (op2))
+// OBSOLETE 		{
+// OBSOLETE 		  /* If the previous opcode was really part of the
+// OBSOLETE 		     prologue and not just a NOP, then we want to
+// OBSOLETE 		     break after both instructions.  */
+// OBSOLETE 		  if (op1 != 0x5E00)
+// OBSOLETE 		    pc += 4;
+// OBSOLETE 		  break;
+// OBSOLETE 		}
+// OBSOLETE 	    }
+// OBSOLETE 	  else
+// OBSOLETE 	    break;
+// OBSOLETE 	}
+// OBSOLETE       pc += 4;
+// OBSOLETE     }
+// OBSOLETE   return pc;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE struct d10v_unwind_cache
+// OBSOLETE {
+// OBSOLETE   /* The previous frame's inner most stack address.  Used as this
+// OBSOLETE      frame ID's stack_addr.  */
+// OBSOLETE   CORE_ADDR prev_sp;
+// OBSOLETE   /* The frame's base, optionally used by the high-level debug info.  */
+// OBSOLETE   CORE_ADDR base;
+// OBSOLETE   int size;
+// OBSOLETE   /* How far the SP and r11 (FP) have been offset from the start of
+// OBSOLETE      the stack frame (as defined by the previous frame's stack
+// OBSOLETE      pointer).  */
+// OBSOLETE   LONGEST sp_offset;
+// OBSOLETE   LONGEST r11_offset;
+// OBSOLETE   int uses_frame;
+// OBSOLETE   /* Table indicating the location of each and every register.  */
+// OBSOLETE   struct trad_frame_saved_reg *saved_regs;
+// OBSOLETE };
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE prologue_find_regs (struct d10v_unwind_cache *info, unsigned short op,
+// OBSOLETE 		    CORE_ADDR addr)
+// OBSOLETE {
+// OBSOLETE   int n;
+// OBSOLETE 
+// OBSOLETE   /* st  rn, @-sp */
+// OBSOLETE   if ((op & 0x7E1F) == 0x6C1F)
+// OBSOLETE     {
+// OBSOLETE       n = (op & 0x1E0) >> 5;
+// OBSOLETE       info->sp_offset -= 2;
+// OBSOLETE       info->saved_regs[n].addr = info->sp_offset;
+// OBSOLETE       return 1;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* st2w  rn, @-sp */
+// OBSOLETE   else if ((op & 0x7E3F) == 0x6E1F)
+// OBSOLETE     {
+// OBSOLETE       n = (op & 0x1E0) >> 5;
+// OBSOLETE       info->sp_offset -= 4;
+// OBSOLETE       info->saved_regs[n + 0].addr = info->sp_offset + 0;
+// OBSOLETE       info->saved_regs[n + 1].addr = info->sp_offset + 2;
+// OBSOLETE       return 1;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* subi  sp, n */
+// OBSOLETE   if ((op & 0x7FE1) == 0x01E1)
+// OBSOLETE     {
+// OBSOLETE       n = (op & 0x1E) >> 1;
+// OBSOLETE       if (n == 0)
+// OBSOLETE 	n = 16;
+// OBSOLETE       info->sp_offset -= n;
+// OBSOLETE       return 1;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* mv  r11, sp */
+// OBSOLETE   if (op == 0x417E)
+// OBSOLETE     {
+// OBSOLETE       info->uses_frame = 1;
+// OBSOLETE       info->r11_offset = info->sp_offset;
+// OBSOLETE       return 1;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* st  rn, @r11 */
+// OBSOLETE   if ((op & 0x7E1F) == 0x6816)
+// OBSOLETE     {
+// OBSOLETE       n = (op & 0x1E0) >> 5;
+// OBSOLETE       info->saved_regs[n].addr = info->r11_offset;
+// OBSOLETE       return 1;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* nop */
+// OBSOLETE   if (op == 0x5E00)
+// OBSOLETE     return 1;
+// OBSOLETE 
+// OBSOLETE   /* st  rn, @sp */
+// OBSOLETE   if ((op & 0x7E1F) == 0x681E)
+// OBSOLETE     {
+// OBSOLETE       n = (op & 0x1E0) >> 5;
+// OBSOLETE       info->saved_regs[n].addr = info->sp_offset;
+// OBSOLETE       return 1;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* st2w  rn, @sp */
+// OBSOLETE   if ((op & 0x7E3F) == 0x3A1E)
+// OBSOLETE     {
+// OBSOLETE       n = (op & 0x1E0) >> 5;
+// OBSOLETE       info->saved_regs[n + 0].addr = info->sp_offset + 0;
+// OBSOLETE       info->saved_regs[n + 1].addr = info->sp_offset + 2;
+// OBSOLETE       return 1;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   return 0;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Put here the code to store, into fi->saved_regs, the addresses of
+// OBSOLETE    the saved registers of frame described by FRAME_INFO.  This
+// OBSOLETE    includes special registers such as pc and fp saved in special ways
+// OBSOLETE    in the stack frame.  sp is even more special: the address we return
+// OBSOLETE    for it IS the sp for the next frame.  */
+// OBSOLETE 
+// OBSOLETE static struct d10v_unwind_cache *
+// OBSOLETE d10v_frame_unwind_cache (struct frame_info *next_frame,
+// OBSOLETE 			 void **this_prologue_cache)
+// OBSOLETE {
+// OBSOLETE   struct gdbarch *gdbarch = get_frame_arch (next_frame);
+// OBSOLETE   CORE_ADDR pc;
+// OBSOLETE   ULONGEST prev_sp;
+// OBSOLETE   ULONGEST this_base;
+// OBSOLETE   unsigned long op;
+// OBSOLETE   unsigned short op1, op2;
+// OBSOLETE   int i;
+// OBSOLETE   struct d10v_unwind_cache *info;
+// OBSOLETE 
+// OBSOLETE   if ((*this_prologue_cache))
+// OBSOLETE     return (*this_prologue_cache);
+// OBSOLETE 
+// OBSOLETE   info = FRAME_OBSTACK_ZALLOC (struct d10v_unwind_cache);
+// OBSOLETE   (*this_prologue_cache) = info;
+// OBSOLETE   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+// OBSOLETE 
+// OBSOLETE   info->size = 0;
+// OBSOLETE   info->sp_offset = 0;
+// OBSOLETE 
+// OBSOLETE   info->uses_frame = 0;
+// OBSOLETE   for (pc = frame_func_unwind (next_frame);
+// OBSOLETE        pc > 0 && pc < frame_pc_unwind (next_frame);
+// OBSOLETE        pc += 4)
+// OBSOLETE     {
+// OBSOLETE       op = get_frame_memory_unsigned (next_frame, pc, 4);
+// OBSOLETE       if ((op & 0xC0000000) == 0xC0000000)
+// OBSOLETE 	{
+// OBSOLETE 	  /* long instruction */
+// OBSOLETE 	  if ((op & 0x3FFF0000) == 0x01FF0000)
+// OBSOLETE 	    {
+// OBSOLETE 	      /* add3 sp,sp,n */
+// OBSOLETE 	      short n = op & 0xFFFF;
+// OBSOLETE 	      info->sp_offset += n;
+// OBSOLETE 	    }
+// OBSOLETE 	  else if ((op & 0x3F0F0000) == 0x340F0000)
+// OBSOLETE 	    {
+// OBSOLETE 	      /* st  rn, @(offset,sp) */
+// OBSOLETE 	      short offset = op & 0xFFFF;
+// OBSOLETE 	      short n = (op >> 20) & 0xF;
+// OBSOLETE 	      info->saved_regs[n].addr = info->sp_offset + offset;
+// OBSOLETE 	    }
+// OBSOLETE 	  else if ((op & 0x3F1F0000) == 0x350F0000)
+// OBSOLETE 	    {
+// OBSOLETE 	      /* st2w  rn, @(offset,sp) */
+// OBSOLETE 	      short offset = op & 0xFFFF;
+// OBSOLETE 	      short n = (op >> 20) & 0xF;
+// OBSOLETE 	      info->saved_regs[n + 0].addr = info->sp_offset + offset + 0;
+// OBSOLETE 	      info->saved_regs[n + 1].addr = info->sp_offset + offset + 2;
+// OBSOLETE 	    }
+// OBSOLETE 	  else
+// OBSOLETE 	    break;
+// OBSOLETE 	}
+// OBSOLETE       else
+// OBSOLETE 	{
+// OBSOLETE 	  /* short instructions */
+// OBSOLETE 	  if ((op & 0xC0000000) == 0x80000000)
+// OBSOLETE 	    {
+// OBSOLETE 	      op2 = (op & 0x3FFF8000) >> 15;
+// OBSOLETE 	      op1 = op & 0x7FFF;
+// OBSOLETE 	    }
+// OBSOLETE 	  else
+// OBSOLETE 	    {
+// OBSOLETE 	      op1 = (op & 0x3FFF8000) >> 15;
+// OBSOLETE 	      op2 = op & 0x7FFF;
+// OBSOLETE 	    }
+// OBSOLETE 	  if (!prologue_find_regs (info, op1, pc) 
+// OBSOLETE 	      || !prologue_find_regs (info, op2, pc))
+// OBSOLETE 	    break;
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   info->size = -info->sp_offset;
+// OBSOLETE 
+// OBSOLETE   /* Compute the previous frame's stack pointer (which is also the
+// OBSOLETE      frame's ID's stack address), and this frame's base pointer.  */
+// OBSOLETE   if (info->uses_frame)
+// OBSOLETE     {
+// OBSOLETE       /* The SP was moved to the FP.  This indicates that a new frame
+// OBSOLETE          was created.  Get THIS frame's FP value by unwinding it from
+// OBSOLETE          the next frame.  */
+// OBSOLETE       frame_unwind_unsigned_register (next_frame, D10V_FP_REGNUM, &this_base);
+// OBSOLETE       /* The FP points at the last saved register.  Adjust the FP back
+// OBSOLETE          to before the first saved register giving the SP.  */
+// OBSOLETE       prev_sp = this_base + info->size;
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     {
+// OBSOLETE       /* Assume that the FP is this frame's SP but with that pushed
+// OBSOLETE          stack space added back.  */
+// OBSOLETE       frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &this_base);
+// OBSOLETE       prev_sp = this_base + info->size;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* Convert that SP/BASE into real addresses.  */
+// OBSOLETE   info->prev_sp =  d10v_make_daddr (prev_sp);
+// OBSOLETE   info->base = d10v_make_daddr (this_base);
+// OBSOLETE 
+// OBSOLETE   /* Adjust all the saved registers so that they contain addresses and
+// OBSOLETE      not offsets.  */
+// OBSOLETE   for (i = 0; i < NUM_REGS - 1; i++)
+// OBSOLETE     if (trad_frame_addr_p (info->saved_regs, i))
+// OBSOLETE       {
+// OBSOLETE 	info->saved_regs[i].addr = (info->prev_sp + info->saved_regs[i].addr);
+// OBSOLETE       }
+// OBSOLETE 
+// OBSOLETE   /* The call instruction moves the caller's PC in the callee's LR.
+// OBSOLETE      Since this is an unwind, do the reverse.  Copy the location of LR
+// OBSOLETE      into PC (the address / regnum) so that a request for PC will be
+// OBSOLETE      converted into a request for the LR.  */
+// OBSOLETE   info->saved_regs[D10V_PC_REGNUM] = info->saved_regs[LR_REGNUM];
+// OBSOLETE 
+// OBSOLETE   /* The previous frame's SP needed to be computed.  Save the computed
+// OBSOLETE      value.  */
+// OBSOLETE   trad_frame_set_value (info->saved_regs, D10V_SP_REGNUM,
+// OBSOLETE 			d10v_make_daddr (prev_sp));
+// OBSOLETE 
+// OBSOLETE   return info;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE d10v_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
+// OBSOLETE 			   struct frame_info *frame, int regnum, int all)
+// OBSOLETE {
+// OBSOLETE   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+// OBSOLETE   if (regnum >= 0)
+// OBSOLETE     {
+// OBSOLETE       default_print_registers_info (gdbarch, file, frame, regnum, all);
+// OBSOLETE       return;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   {
+// OBSOLETE     ULONGEST pc, psw, rpt_s, rpt_e, rpt_c;
+// OBSOLETE     pc = get_frame_register_unsigned (frame, D10V_PC_REGNUM);
+// OBSOLETE     psw = get_frame_register_unsigned (frame, PSW_REGNUM);
+// OBSOLETE     rpt_s = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_s", -1));
+// OBSOLETE     rpt_e = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_e", -1));
+// OBSOLETE     rpt_c = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_c", -1));
+// OBSOLETE     fprintf_filtered (file, "PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n",
+// OBSOLETE 		     (long) pc, (long) d10v_make_iaddr (pc), (long) psw,
+// OBSOLETE 		     (long) rpt_s, (long) rpt_e, (long) rpt_c);
+// OBSOLETE   }
+// OBSOLETE 
+// OBSOLETE   {
+// OBSOLETE     int group;
+// OBSOLETE     for (group = 0; group < 16; group += 8)
+// OBSOLETE       {
+// OBSOLETE 	int r;
+// OBSOLETE 	fprintf_filtered (file, "R%d-R%-2d", group, group + 7);
+// OBSOLETE 	for (r = group; r < group + 8; r++)
+// OBSOLETE 	  {
+// OBSOLETE 	    ULONGEST tmp;
+// OBSOLETE 	    tmp = get_frame_register_unsigned (frame, r);
+// OBSOLETE 	    fprintf_filtered (file, " %04lx", (long) tmp);
+// OBSOLETE 	  }
+// OBSOLETE 	fprintf_filtered (file, "\n");
+// OBSOLETE       }
+// OBSOLETE   }
+// OBSOLETE 
+// OBSOLETE   /* Note: The IMAP/DMAP registers don't participate in function
+// OBSOLETE      calls.  Don't bother trying to unwind them.  */
+// OBSOLETE 
+// OBSOLETE   {
+// OBSOLETE     int a;
+// OBSOLETE     for (a = 0; a < NR_IMAP_REGS; a++)
+// OBSOLETE       {
+// OBSOLETE 	if (a > 0)
+// OBSOLETE 	  fprintf_filtered (file, "    ");
+// OBSOLETE 	fprintf_filtered (file, "IMAP%d %04lx", a,
+// OBSOLETE 			  tdep->imap_register (current_regcache, a));
+// OBSOLETE       }
+// OBSOLETE     if (nr_dmap_regs (gdbarch) == 1)
+// OBSOLETE       /* Registers DMAP0 and DMAP1 are constant.  Just return dmap2.  */
+// OBSOLETE       fprintf_filtered (file, "    DMAP %04lx\n",
+// OBSOLETE 			tdep->dmap_register (current_regcache, 2));
+// OBSOLETE     else
+// OBSOLETE       {
+// OBSOLETE 	for (a = 0; a < nr_dmap_regs (gdbarch); a++)
+// OBSOLETE 	  {
+// OBSOLETE 	    fprintf_filtered (file, "    DMAP%d %04lx", a,
+// OBSOLETE 			      tdep->dmap_register (current_regcache, a));
+// OBSOLETE 	  }
+// OBSOLETE 	fprintf_filtered (file, "\n");
+// OBSOLETE       }
+// OBSOLETE   }
+// OBSOLETE 
+// OBSOLETE   {
+// OBSOLETE     char num[MAX_REGISTER_SIZE];
+// OBSOLETE     int a;
+// OBSOLETE     fprintf_filtered (file, "A0-A%d", NR_A_REGS - 1);
+// OBSOLETE     for (a = a0_regnum (gdbarch); a < a0_regnum (gdbarch) + NR_A_REGS; a++)
+// OBSOLETE       {
+// OBSOLETE 	int i;
+// OBSOLETE 	fprintf_filtered (file, "  ");
+// OBSOLETE 	get_frame_register (frame, a, num);
+// OBSOLETE 	for (i = 0; i < register_size (gdbarch, a); i++)
+// OBSOLETE 	  {
+// OBSOLETE 	    fprintf_filtered (file, "%02x", (num[i] & 0xff));
+// OBSOLETE 	  }
+// OBSOLETE       }
+// OBSOLETE   }
+// OBSOLETE   fprintf_filtered (file, "\n");
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE show_regs (char *args, int from_tty)
+// OBSOLETE {
+// OBSOLETE   d10v_print_registers_info (current_gdbarch, gdb_stdout,
+// OBSOLETE 			     get_current_frame (), -1, 1);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_read_pc (ptid_t ptid)
+// OBSOLETE {
+// OBSOLETE   ptid_t save_ptid;
+// OBSOLETE   CORE_ADDR pc;
+// OBSOLETE   CORE_ADDR retval;
+// OBSOLETE 
+// OBSOLETE   save_ptid = inferior_ptid;
+// OBSOLETE   inferior_ptid = ptid;
+// OBSOLETE   pc = (int) read_register (D10V_PC_REGNUM);
+// OBSOLETE   inferior_ptid = save_ptid;
+// OBSOLETE   retval = d10v_make_iaddr (pc);
+// OBSOLETE   return retval;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE d10v_write_pc (CORE_ADDR val, ptid_t ptid)
+// OBSOLETE {
+// OBSOLETE   ptid_t save_ptid;
+// OBSOLETE 
+// OBSOLETE   save_ptid = inferior_ptid;
+// OBSOLETE   inferior_ptid = ptid;
+// OBSOLETE   write_register (D10V_PC_REGNUM, d10v_convert_iaddr_to_raw (val));
+// OBSOLETE   inferior_ptid = save_ptid;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
+// OBSOLETE {
+// OBSOLETE   ULONGEST sp;
+// OBSOLETE   frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &sp);
+// OBSOLETE   return d10v_make_daddr (sp);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* When arguments must be pushed onto the stack, they go on in reverse
+// OBSOLETE    order.  The below implements a FILO (stack) to do this.  */
+// OBSOLETE 
+// OBSOLETE struct stack_item
+// OBSOLETE {
+// OBSOLETE   int len;
+// OBSOLETE   struct stack_item *prev;
+// OBSOLETE   void *data;
+// OBSOLETE };
+// OBSOLETE 
+// OBSOLETE static struct stack_item *push_stack_item (struct stack_item *prev,
+// OBSOLETE 					   void *contents, int len);
+// OBSOLETE static struct stack_item *
+// OBSOLETE push_stack_item (struct stack_item *prev, void *contents, int len)
+// OBSOLETE {
+// OBSOLETE   struct stack_item *si;
+// OBSOLETE   si = xmalloc (sizeof (struct stack_item));
+// OBSOLETE   si->data = xmalloc (len);
+// OBSOLETE   si->len = len;
+// OBSOLETE   si->prev = prev;
+// OBSOLETE   memcpy (si->data, contents, len);
+// OBSOLETE   return si;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static struct stack_item *pop_stack_item (struct stack_item *si);
+// OBSOLETE static struct stack_item *
+// OBSOLETE pop_stack_item (struct stack_item *si)
+// OBSOLETE {
+// OBSOLETE   struct stack_item *dead = si;
+// OBSOLETE   si = si->prev;
+// OBSOLETE   xfree (dead->data);
+// OBSOLETE   xfree (dead);
+// OBSOLETE   return si;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_push_dummy_code (struct gdbarch *gdbarch,
+// OBSOLETE 		      CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
+// OBSOLETE 		      struct value **args, int nargs,
+// OBSOLETE 		      struct type *value_type,
+// OBSOLETE 		      CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+// OBSOLETE {
+// OBSOLETE   /* Allocate space sufficient for a breakpoint.  */
+// OBSOLETE   sp = (sp - 4) & ~3;
+// OBSOLETE   /* Store the address of that breakpoint taking care to first convert
+// OBSOLETE      it into a code (IADDR) address from a stack (DADDR) address.
+// OBSOLETE      This of course assumes that the two virtual addresses map onto
+// OBSOLETE      the same real address.  */
+// OBSOLETE   (*bp_addr) = d10v_make_iaddr (d10v_convert_iaddr_to_raw (sp));
+// OBSOLETE   /* d10v always starts the call at the callee's entry point.  */
+// OBSOLETE   (*real_pc) = funaddr;
+// OBSOLETE   return sp;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
+// OBSOLETE 		      struct regcache *regcache, CORE_ADDR bp_addr,
+// OBSOLETE 		      int nargs, struct value **args, CORE_ADDR sp, 
+// OBSOLETE 		      int struct_return, CORE_ADDR struct_addr)
+// OBSOLETE {
+// OBSOLETE   int i;
+// OBSOLETE   int regnum = ARG1_REGNUM;
+// OBSOLETE   struct stack_item *si = NULL;
+// OBSOLETE   long val;
+// OBSOLETE 
+// OBSOLETE   /* Set the return address.  For the d10v, the return breakpoint is
+// OBSOLETE      always at BP_ADDR.  */
+// OBSOLETE   regcache_cooked_write_unsigned (regcache, LR_REGNUM,
+// OBSOLETE 				  d10v_convert_iaddr_to_raw (bp_addr));
+// OBSOLETE 
+// OBSOLETE   /* If STRUCT_RETURN is true, then the struct return address (in
+// OBSOLETE      STRUCT_ADDR) will consume the first argument-passing register.
+// OBSOLETE      Both adjust the register count and store that value.  */
+// OBSOLETE   if (struct_return)
+// OBSOLETE     {
+// OBSOLETE       regcache_cooked_write_unsigned (regcache, regnum, struct_addr);
+// OBSOLETE       regnum++;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* Fill in registers and arg lists */
+// OBSOLETE   for (i = 0; i < nargs; i++)
+// OBSOLETE     {
+// OBSOLETE       struct value *arg = args[i];
+// OBSOLETE       struct type *type = check_typedef (VALUE_TYPE (arg));
+// OBSOLETE       char *contents = VALUE_CONTENTS (arg);
+// OBSOLETE       int len = TYPE_LENGTH (type);
+// OBSOLETE       int aligned_regnum = (regnum + 1) & ~1;
+// OBSOLETE 
+// OBSOLETE       /* printf ("push: type=%d len=%d\n", TYPE_CODE (type), len); */
+// OBSOLETE       if (len <= 2 && regnum <= ARGN_REGNUM)
+// OBSOLETE 	/* fits in a single register, do not align */
+// OBSOLETE 	{
+// OBSOLETE 	  val = extract_unsigned_integer (contents, len);
+// OBSOLETE 	  regcache_cooked_write_unsigned (regcache, regnum++, val);
+// OBSOLETE 	}
+// OBSOLETE       else if (len <= (ARGN_REGNUM - aligned_regnum + 1) * 2)
+// OBSOLETE 	/* value fits in remaining registers, store keeping left
+// OBSOLETE 	   aligned */
+// OBSOLETE 	{
+// OBSOLETE 	  int b;
+// OBSOLETE 	  regnum = aligned_regnum;
+// OBSOLETE 	  for (b = 0; b < (len & ~1); b += 2)
+// OBSOLETE 	    {
+// OBSOLETE 	      val = extract_unsigned_integer (&contents[b], 2);
+// OBSOLETE 	      regcache_cooked_write_unsigned (regcache, regnum++, val);
+// OBSOLETE 	    }
+// OBSOLETE 	  if (b < len)
+// OBSOLETE 	    {
+// OBSOLETE 	      val = extract_unsigned_integer (&contents[b], 1);
+// OBSOLETE 	      regcache_cooked_write_unsigned (regcache, regnum++, (val << 8));
+// OBSOLETE 	    }
+// OBSOLETE 	}
+// OBSOLETE       else
+// OBSOLETE 	{
+// OBSOLETE 	  /* arg will go onto stack */
+// OBSOLETE 	  regnum = ARGN_REGNUM + 1;
+// OBSOLETE 	  si = push_stack_item (si, contents, len);
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   while (si)
+// OBSOLETE     {
+// OBSOLETE       sp = (sp - si->len) & ~1;
+// OBSOLETE       write_memory (sp, si->data, si->len);
+// OBSOLETE       si = pop_stack_item (si);
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* Finally, update the SP register.  */
+// OBSOLETE   regcache_cooked_write_unsigned (regcache, D10V_SP_REGNUM,
+// OBSOLETE 				  d10v_convert_daddr_to_raw (sp));
+// OBSOLETE 
+// OBSOLETE   return sp;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Translate a GDB virtual ADDR/LEN into a format the remote target
+// OBSOLETE    understands.  Returns number of bytes that can be transfered
+// OBSOLETE    starting at TARG_ADDR.  Return ZERO if no bytes can be transfered
+// OBSOLETE    (segmentation fault).  Since the simulator knows all about how the
+// OBSOLETE    VM system works, we just call that to do the translation.  */
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE remote_d10v_translate_xfer_address (struct gdbarch *gdbarch,
+// OBSOLETE 				    struct regcache *regcache,
+// OBSOLETE 				    CORE_ADDR memaddr, int nr_bytes,
+// OBSOLETE 				    CORE_ADDR *targ_addr, int *targ_len)
+// OBSOLETE {
+// OBSOLETE   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+// OBSOLETE   long out_addr;
+// OBSOLETE   long out_len;
+// OBSOLETE   out_len = sim_d10v_translate_addr (memaddr, nr_bytes, &out_addr, regcache,
+// OBSOLETE 				     tdep->dmap_register, tdep->imap_register);
+// OBSOLETE   *targ_addr = out_addr;
+// OBSOLETE   *targ_len = out_len;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE /* The following code implements access to, and display of, the D10V's
+// OBSOLETE    instruction trace buffer.  The buffer consists of 64K or more
+// OBSOLETE    4-byte words of data, of which each words includes an 8-bit count,
+// OBSOLETE    an 8-bit segment number, and a 16-bit instruction address.
+// OBSOLETE 
+// OBSOLETE    In theory, the trace buffer is continuously capturing instruction
+// OBSOLETE    data that the CPU presents on its "debug bus", but in practice, the
+// OBSOLETE    ROMified GDB stub only enables tracing when it continues or steps
+// OBSOLETE    the program, and stops tracing when the program stops; so it
+// OBSOLETE    actually works for GDB to read the buffer counter out of memory and
+// OBSOLETE    then read each trace word.  The counter records where the tracing
+// OBSOLETE    stops, but there is no record of where it started, so we remember
+// OBSOLETE    the PC when we resumed and then search backwards in the trace
+// OBSOLETE    buffer for a word that includes that address.  This is not perfect,
+// OBSOLETE    because you will miss trace data if the resumption PC is the target
+// OBSOLETE    of a branch.  (The value of the buffer counter is semi-random, any
+// OBSOLETE    trace data from a previous program stop is gone.)  */
+// OBSOLETE 
+// OBSOLETE /* The address of the last word recorded in the trace buffer.  */
+// OBSOLETE 
+// OBSOLETE #define DBBC_ADDR (0xd80000)
+// OBSOLETE 
+// OBSOLETE /* The base of the trace buffer, at least for the "Board_0".  */
+// OBSOLETE 
+// OBSOLETE #define TRACE_BUFFER_BASE (0xf40000)
+// OBSOLETE 
+// OBSOLETE static void trace_command (char *, int);
+// OBSOLETE 
+// OBSOLETE static void untrace_command (char *, int);
+// OBSOLETE 
+// OBSOLETE static void trace_info (char *, int);
+// OBSOLETE 
+// OBSOLETE static void tdisassemble_command (char *, int);
+// OBSOLETE 
+// OBSOLETE static void display_trace (int, int);
+// OBSOLETE 
+// OBSOLETE /* True when instruction traces are being collected.  */
+// OBSOLETE 
+// OBSOLETE static int tracing;
+// OBSOLETE 
+// OBSOLETE /* Remembered PC.  */
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR last_pc;
+// OBSOLETE 
+// OBSOLETE /* True when trace output should be displayed whenever program stops.  */
+// OBSOLETE 
+// OBSOLETE static int trace_display;
+// OBSOLETE 
+// OBSOLETE /* True when trace listing should include source lines.  */
+// OBSOLETE 
+// OBSOLETE static int default_trace_show_source = 1;
+// OBSOLETE 
+// OBSOLETE struct trace_buffer
+// OBSOLETE   {
+// OBSOLETE     int size;
+// OBSOLETE     short *counts;
+// OBSOLETE     CORE_ADDR *addrs;
+// OBSOLETE   }
+// OBSOLETE trace_data;
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE trace_command (char *args, int from_tty)
+// OBSOLETE {
+// OBSOLETE   /* Clear the host-side trace buffer, allocating space if needed.  */
+// OBSOLETE   trace_data.size = 0;
+// OBSOLETE   if (trace_data.counts == NULL)
+// OBSOLETE     trace_data.counts = XCALLOC (65536, short);
+// OBSOLETE   if (trace_data.addrs == NULL)
+// OBSOLETE     trace_data.addrs = XCALLOC (65536, CORE_ADDR);
+// OBSOLETE 
+// OBSOLETE   tracing = 1;
+// OBSOLETE 
+// OBSOLETE   printf_filtered ("Tracing is now on.\n");
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE untrace_command (char *args, int from_tty)
+// OBSOLETE {
+// OBSOLETE   tracing = 0;
+// OBSOLETE 
+// OBSOLETE   printf_filtered ("Tracing is now off.\n");
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE trace_info (char *args, int from_tty)
+// OBSOLETE {
+// OBSOLETE   int i;
+// OBSOLETE 
+// OBSOLETE   if (trace_data.size)
+// OBSOLETE     {
+// OBSOLETE       printf_filtered ("%d entries in trace buffer:\n", trace_data.size);
+// OBSOLETE 
+// OBSOLETE       for (i = 0; i < trace_data.size; ++i)
+// OBSOLETE 	{
+// OBSOLETE 	  printf_filtered ("%d: %d instruction%s at 0x%s\n",
+// OBSOLETE 			   i,
+// OBSOLETE 			   trace_data.counts[i],
+// OBSOLETE 			   (trace_data.counts[i] == 1 ? "" : "s"),
+// OBSOLETE 			   paddr_nz (trace_data.addrs[i]));
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     printf_filtered ("No entries in trace buffer.\n");
+// OBSOLETE 
+// OBSOLETE   printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off"));
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE d10v_eva_prepare_to_trace (void)
+// OBSOLETE {
+// OBSOLETE   if (!tracing)
+// OBSOLETE     return;
+// OBSOLETE 
+// OBSOLETE   last_pc = read_register (D10V_PC_REGNUM);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Collect trace data from the target board and format it into a form
+// OBSOLETE    more useful for display.  */
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE d10v_eva_get_trace_data (void)
+// OBSOLETE {
+// OBSOLETE   int count, i, j, oldsize;
+// OBSOLETE   int trace_addr, trace_seg, trace_cnt, next_cnt;
+// OBSOLETE   unsigned int last_trace, trace_word, next_word;
+// OBSOLETE   unsigned int *tmpspace;
+// OBSOLETE 
+// OBSOLETE   if (!tracing)
+// OBSOLETE     return;
+// OBSOLETE 
+// OBSOLETE   tmpspace = xmalloc (65536 * sizeof (unsigned int));
+// OBSOLETE 
+// OBSOLETE   last_trace = read_memory_unsigned_integer (DBBC_ADDR, 2) << 2;
+// OBSOLETE 
+// OBSOLETE   /* Collect buffer contents from the target, stopping when we reach
+// OBSOLETE      the word recorded when execution resumed.  */
+// OBSOLETE 
+// OBSOLETE   count = 0;
+// OBSOLETE   while (last_trace > 0)
+// OBSOLETE     {
+// OBSOLETE       QUIT;
+// OBSOLETE       trace_word =
+// OBSOLETE 	read_memory_unsigned_integer (TRACE_BUFFER_BASE + last_trace, 4);
+// OBSOLETE       trace_addr = trace_word & 0xffff;
+// OBSOLETE       last_trace -= 4;
+// OBSOLETE       /* Ignore an apparently nonsensical entry.  */
+// OBSOLETE       if (trace_addr == 0xffd5)
+// OBSOLETE 	continue;
+// OBSOLETE       tmpspace[count++] = trace_word;
+// OBSOLETE       if (trace_addr == last_pc)
+// OBSOLETE 	break;
+// OBSOLETE       if (count > 65535)
+// OBSOLETE 	break;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* Move the data to the host-side trace buffer, adjusting counts to
+// OBSOLETE      include the last instruction executed and transforming the address
+// OBSOLETE      into something that GDB likes.  */
+// OBSOLETE 
+// OBSOLETE   for (i = 0; i < count; ++i)
+// OBSOLETE     {
+// OBSOLETE       trace_word = tmpspace[i];
+// OBSOLETE       next_word = ((i == 0) ? 0 : tmpspace[i - 1]);
+// OBSOLETE       trace_addr = trace_word & 0xffff;
+// OBSOLETE       next_cnt = (next_word >> 24) & 0xff;
+// OBSOLETE       j = trace_data.size + count - i - 1;
+// OBSOLETE       trace_data.addrs[j] = (trace_addr << 2) + 0x1000000;
+// OBSOLETE       trace_data.counts[j] = next_cnt + 1;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   oldsize = trace_data.size;
+// OBSOLETE   trace_data.size += count;
+// OBSOLETE 
+// OBSOLETE   xfree (tmpspace);
+// OBSOLETE 
+// OBSOLETE   if (trace_display)
+// OBSOLETE     display_trace (oldsize, trace_data.size);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE tdisassemble_command (char *arg, int from_tty)
+// OBSOLETE {
+// OBSOLETE   int i, count;
+// OBSOLETE   CORE_ADDR low, high;
+// OBSOLETE 
+// OBSOLETE   if (!arg)
+// OBSOLETE     {
+// OBSOLETE       low = 0;
+// OBSOLETE       high = trace_data.size;
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     { 
+// OBSOLETE       char *space_index = strchr (arg, ' ');
+// OBSOLETE       if (space_index == NULL)
+// OBSOLETE 	{
+// OBSOLETE 	  low = parse_and_eval_address (arg);
+// OBSOLETE 	  high = low + 5;
+// OBSOLETE 	}
+// OBSOLETE       else
+// OBSOLETE 	{
+// OBSOLETE 	  /* Two arguments.  */
+// OBSOLETE 	  *space_index = '\0';
+// OBSOLETE 	  low = parse_and_eval_address (arg);
+// OBSOLETE 	  high = parse_and_eval_address (space_index + 1);
+// OBSOLETE 	  if (high < low)
+// OBSOLETE 	    high = low;
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   printf_filtered ("Dump of trace from %s to %s:\n", 
+// OBSOLETE 		   paddr_u (low), paddr_u (high));
+// OBSOLETE 
+// OBSOLETE   display_trace (low, high);
+// OBSOLETE 
+// OBSOLETE   printf_filtered ("End of trace dump.\n");
+// OBSOLETE   gdb_flush (gdb_stdout);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE display_trace (int low, int high)
+// OBSOLETE {
+// OBSOLETE   int i, count, trace_show_source, first, suppress;
+// OBSOLETE   CORE_ADDR next_address;
+// OBSOLETE 
+// OBSOLETE   trace_show_source = default_trace_show_source;
+// OBSOLETE   if (!have_full_symbols () && !have_partial_symbols ())
+// OBSOLETE     {
+// OBSOLETE       trace_show_source = 0;
+// OBSOLETE       printf_filtered ("No symbol table is loaded.  Use the \"file\" command.\n");
+// OBSOLETE       printf_filtered ("Trace will not display any source.\n");
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   first = 1;
+// OBSOLETE   suppress = 0;
+// OBSOLETE   for (i = low; i < high; ++i)
+// OBSOLETE     {
+// OBSOLETE       next_address = trace_data.addrs[i];
+// OBSOLETE       count = trace_data.counts[i];
+// OBSOLETE       while (count-- > 0)
+// OBSOLETE 	{
+// OBSOLETE 	  QUIT;
+// OBSOLETE 	  if (trace_show_source)
+// OBSOLETE 	    {
+// OBSOLETE 	      struct symtab_and_line sal, sal_prev;
+// OBSOLETE 
+// OBSOLETE 	      sal_prev = find_pc_line (next_address - 4, 0);
+// OBSOLETE 	      sal = find_pc_line (next_address, 0);
+// OBSOLETE 
+// OBSOLETE 	      if (sal.symtab)
+// OBSOLETE 		{
+// OBSOLETE 		  if (first || sal.line != sal_prev.line)
+// OBSOLETE 		    print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
+// OBSOLETE 		  suppress = 0;
+// OBSOLETE 		}
+// OBSOLETE 	      else
+// OBSOLETE 		{
+// OBSOLETE 		  if (!suppress)
+// OBSOLETE 		    /* FIXME-32x64--assumes sal.pc fits in long.  */
+// OBSOLETE 		    printf_filtered ("No source file for address %s.\n",
+// OBSOLETE 				     hex_string ((unsigned long) sal.pc));
+// OBSOLETE 		  suppress = 1;
+// OBSOLETE 		}
+// OBSOLETE 	    }
+// OBSOLETE 	  first = 0;
+// OBSOLETE 	  print_address (next_address, gdb_stdout);
+// OBSOLETE 	  printf_filtered (":");
+// OBSOLETE 	  printf_filtered ("\t");
+// OBSOLETE 	  wrap_here ("    ");
+// OBSOLETE 	  next_address += gdb_print_insn (next_address, gdb_stdout);
+// OBSOLETE 	  printf_filtered ("\n");
+// OBSOLETE 	  gdb_flush (gdb_stdout);
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+// OBSOLETE {
+// OBSOLETE   ULONGEST pc;
+// OBSOLETE   frame_unwind_unsigned_register (next_frame, D10V_PC_REGNUM, &pc);
+// OBSOLETE   return d10v_make_iaddr (pc);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Given a GDB frame, determine the address of the calling function's
+// OBSOLETE    frame.  This will be used to create a new GDB frame struct.  */
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE d10v_frame_this_id (struct frame_info *next_frame,
+// OBSOLETE 		    void **this_prologue_cache,
+// OBSOLETE 		    struct frame_id *this_id)
+// OBSOLETE {
+// OBSOLETE   struct d10v_unwind_cache *info
+// OBSOLETE     = d10v_frame_unwind_cache (next_frame, this_prologue_cache);
+// OBSOLETE   CORE_ADDR base;
+// OBSOLETE   CORE_ADDR func;
+// OBSOLETE   struct frame_id id;
+// OBSOLETE 
+// OBSOLETE   /* The FUNC is easy.  */
+// OBSOLETE   func = frame_func_unwind (next_frame);
+// OBSOLETE 
+// OBSOLETE   /* Hopefully the prologue analysis either correctly determined the
+// OBSOLETE      frame's base (which is the SP from the previous frame), or set
+// OBSOLETE      that base to "NULL".  */
+// OBSOLETE   base = info->prev_sp;
+// OBSOLETE   if (base == STACK_START || base == 0)
+// OBSOLETE     return;
+// OBSOLETE 
+// OBSOLETE   id = frame_id_build (base, func);
+// OBSOLETE 
+// OBSOLETE   (*this_id) = id;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE d10v_frame_prev_register (struct frame_info *next_frame,
+// OBSOLETE 			  void **this_prologue_cache,
+// OBSOLETE 			  int regnum, int *optimizedp,
+// OBSOLETE 			  enum lval_type *lvalp, CORE_ADDR *addrp,
+// OBSOLETE 			  int *realnump, void *bufferp)
+// OBSOLETE {
+// OBSOLETE   struct d10v_unwind_cache *info
+// OBSOLETE     = d10v_frame_unwind_cache (next_frame, this_prologue_cache);
+// OBSOLETE   trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
+// OBSOLETE 				optimizedp, lvalp, addrp, realnump, bufferp);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static const struct frame_unwind d10v_frame_unwind = {
+// OBSOLETE   NORMAL_FRAME,
+// OBSOLETE   d10v_frame_this_id,
+// OBSOLETE   d10v_frame_prev_register
+// OBSOLETE };
+// OBSOLETE 
+// OBSOLETE static const struct frame_unwind *
+// OBSOLETE d10v_frame_sniffer (struct frame_info *next_frame)
+// OBSOLETE {
+// OBSOLETE   return &d10v_frame_unwind;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static CORE_ADDR
+// OBSOLETE d10v_frame_base_address (struct frame_info *next_frame, void **this_cache)
+// OBSOLETE {
+// OBSOLETE   struct d10v_unwind_cache *info
+// OBSOLETE     = d10v_frame_unwind_cache (next_frame, this_cache);
+// OBSOLETE   return info->base;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static const struct frame_base d10v_frame_base = {
+// OBSOLETE   &d10v_frame_unwind,
+// OBSOLETE   d10v_frame_base_address,
+// OBSOLETE   d10v_frame_base_address,
+// OBSOLETE   d10v_frame_base_address
+// OBSOLETE };
+// OBSOLETE 
+// OBSOLETE /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
+// OBSOLETE    dummy frame.  The frame ID's base needs to match the TOS value
+// OBSOLETE    saved by save_dummy_frame_tos(), and the PC match the dummy frame's
+// OBSOLETE    breakpoint.  */
+// OBSOLETE 
+// OBSOLETE static struct frame_id
+// OBSOLETE d10v_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+// OBSOLETE {
+// OBSOLETE   return frame_id_build (d10v_unwind_sp (gdbarch, next_frame),
+// OBSOLETE 			 frame_pc_unwind (next_frame));
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static gdbarch_init_ftype d10v_gdbarch_init;
+// OBSOLETE 
+// OBSOLETE static struct gdbarch *
+// OBSOLETE d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+// OBSOLETE {
+// OBSOLETE   struct gdbarch *gdbarch;
+// OBSOLETE   int d10v_num_regs;
+// OBSOLETE   struct gdbarch_tdep *tdep;
+// OBSOLETE   gdbarch_register_name_ftype *d10v_register_name;
+// OBSOLETE   gdbarch_register_sim_regno_ftype *d10v_register_sim_regno;
+// OBSOLETE 
+// OBSOLETE   /* Find a candidate among the list of pre-declared architectures.  */
+// OBSOLETE   arches = gdbarch_list_lookup_by_info (arches, &info);
+// OBSOLETE   if (arches != NULL)
+// OBSOLETE     return arches->gdbarch;
+// OBSOLETE 
+// OBSOLETE   /* None found, create a new architecture from the information
+// OBSOLETE      provided.  */
+// OBSOLETE   tdep = XMALLOC (struct gdbarch_tdep);
+// OBSOLETE   gdbarch = gdbarch_alloc (&info, tdep);
+// OBSOLETE 
+// OBSOLETE   switch (info.bfd_arch_info->mach)
+// OBSOLETE     {
+// OBSOLETE     case bfd_mach_d10v_ts2:
+// OBSOLETE       d10v_num_regs = 37;
+// OBSOLETE       d10v_register_name = d10v_ts2_register_name;
+// OBSOLETE       d10v_register_sim_regno = d10v_ts2_register_sim_regno;
+// OBSOLETE       tdep->a0_regnum = TS2_A0_REGNUM;
+// OBSOLETE       tdep->nr_dmap_regs = TS2_NR_DMAP_REGS;
+// OBSOLETE       tdep->dmap_register = d10v_ts2_dmap_register;
+// OBSOLETE       tdep->imap_register = d10v_ts2_imap_register;
+// OBSOLETE       break;
+// OBSOLETE     default:
+// OBSOLETE     case bfd_mach_d10v_ts3:
+// OBSOLETE       d10v_num_regs = 42;
+// OBSOLETE       d10v_register_name = d10v_ts3_register_name;
+// OBSOLETE       d10v_register_sim_regno = d10v_ts3_register_sim_regno;
+// OBSOLETE       tdep->a0_regnum = TS3_A0_REGNUM;
+// OBSOLETE       tdep->nr_dmap_regs = TS3_NR_DMAP_REGS;
+// OBSOLETE       tdep->dmap_register = d10v_ts3_dmap_register;
+// OBSOLETE       tdep->imap_register = d10v_ts3_imap_register;
+// OBSOLETE       break;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_read_pc (gdbarch, d10v_read_pc);
+// OBSOLETE   set_gdbarch_write_pc (gdbarch, d10v_write_pc);
+// OBSOLETE   set_gdbarch_unwind_sp (gdbarch, d10v_unwind_sp);
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_num_regs (gdbarch, d10v_num_regs);
+// OBSOLETE   set_gdbarch_sp_regnum (gdbarch, D10V_SP_REGNUM);
+// OBSOLETE   set_gdbarch_register_name (gdbarch, d10v_register_name);
+// OBSOLETE   set_gdbarch_register_type (gdbarch, d10v_register_type);
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+// OBSOLETE   set_gdbarch_addr_bit (gdbarch, 32);
+// OBSOLETE   set_gdbarch_address_to_pointer (gdbarch, d10v_address_to_pointer);
+// OBSOLETE   set_gdbarch_pointer_to_address (gdbarch, d10v_pointer_to_address);
+// OBSOLETE   set_gdbarch_integer_to_address (gdbarch, d10v_integer_to_address);
+// OBSOLETE   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+// OBSOLETE   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+// OBSOLETE   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+// OBSOLETE   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
+// OBSOLETE   /* NOTE: The d10v as a 32 bit ``float'' and ``double''. ``long
+// OBSOLETE      double'' is 64 bits.  */
+// OBSOLETE   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+// OBSOLETE   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+// OBSOLETE   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
+// OBSOLETE   switch (info.byte_order)
+// OBSOLETE     {
+// OBSOLETE     case BFD_ENDIAN_BIG:
+// OBSOLETE       set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_big);
+// OBSOLETE       set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_big);
+// OBSOLETE       set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
+// OBSOLETE       break;
+// OBSOLETE     case BFD_ENDIAN_LITTLE:
+// OBSOLETE       set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little);
+// OBSOLETE       set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_little);
+// OBSOLETE       set_gdbarch_long_double_format (gdbarch, 
+// OBSOLETE 				      &floatformat_ieee_double_little);
+// OBSOLETE       break;
+// OBSOLETE     default:
+// OBSOLETE       internal_error (__FILE__, __LINE__,
+// OBSOLETE 		      "d10v_gdbarch_init: bad byte order for float format");
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_return_value (gdbarch, d10v_return_value);
+// OBSOLETE   set_gdbarch_push_dummy_code (gdbarch, d10v_push_dummy_code);
+// OBSOLETE   set_gdbarch_push_dummy_call (gdbarch, d10v_push_dummy_call);
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_skip_prologue (gdbarch, d10v_skip_prologue);
+// OBSOLETE   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
+// OBSOLETE   set_gdbarch_decr_pc_after_break (gdbarch, 4);
+// OBSOLETE   set_gdbarch_breakpoint_from_pc (gdbarch, d10v_breakpoint_from_pc);
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_remote_translate_xfer_address (gdbarch, 
+// OBSOLETE 					     remote_d10v_translate_xfer_address);
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_frame_align (gdbarch, d10v_frame_align);
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_register_sim_regno (gdbarch, d10v_register_sim_regno);
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_print_registers_info (gdbarch, d10v_print_registers_info);
+// OBSOLETE 
+// OBSOLETE   frame_unwind_append_sniffer (gdbarch, d10v_frame_sniffer);
+// OBSOLETE   frame_base_set_default (gdbarch, &d10v_frame_base);
+// OBSOLETE 
+// OBSOLETE   /* Methods for saving / extracting a dummy frame's ID.  The ID's
+// OBSOLETE      stack address must match the SP value returned by
+// OBSOLETE      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
+// OBSOLETE   set_gdbarch_unwind_dummy_id (gdbarch, d10v_unwind_dummy_id);
+// OBSOLETE 
+// OBSOLETE   /* Return the unwound PC value.  */
+// OBSOLETE   set_gdbarch_unwind_pc (gdbarch, d10v_unwind_pc);
+// OBSOLETE 
+// OBSOLETE   set_gdbarch_print_insn (gdbarch, print_insn_d10v);
+// OBSOLETE 
+// OBSOLETE   return gdbarch;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE _initialize_d10v_tdep (void)
+// OBSOLETE {
+// OBSOLETE   register_gdbarch_init (bfd_arch_d10v, d10v_gdbarch_init);
+// OBSOLETE 
+// OBSOLETE   deprecated_target_resume_hook = d10v_eva_prepare_to_trace;
+// OBSOLETE   deprecated_target_wait_loop_hook = d10v_eva_get_trace_data;
+// OBSOLETE 
+// OBSOLETE   deprecate_cmd (add_com ("regs", class_vars, show_regs, 
+// OBSOLETE 			  "Print all registers"),
+// OBSOLETE 		 "info registers");
+// OBSOLETE 
+// OBSOLETE   add_com ("itrace", class_support, trace_command,
+// OBSOLETE 	   "Enable tracing of instruction execution.");
+// OBSOLETE 
+// OBSOLETE   add_com ("iuntrace", class_support, untrace_command,
+// OBSOLETE 	   "Disable tracing of instruction execution.");
+// OBSOLETE 
+// OBSOLETE   add_com ("itdisassemble", class_vars, tdisassemble_command,
+// OBSOLETE 	   "Disassemble the trace buffer.\n\
+// OBSOLETE Two optional arguments specify a range of trace buffer entries\n\
+// OBSOLETE as reported by info trace (NOT addresses!).");
+// OBSOLETE 
+// OBSOLETE   add_info ("itrace", trace_info,
+// OBSOLETE 	    "Display info about the trace data buffer.");
+// OBSOLETE 
+// OBSOLETE   add_setshow_boolean_cmd ("itracedisplay", no_class, &trace_display, "\
+// OBSOLETE Set automatic display of trace.", "\
+// OBSOLETE Show automatic display of trace.", "\
+// OBSOLETE Controls the display of d10v specific instruction trace information.", "\
+// OBSOLETE Automatic display of trace is %s.",
+// OBSOLETE 			   NULL, NULL, &setlist, &showlist);
+// OBSOLETE   add_setshow_boolean_cmd ("itracesource", no_class,
+// OBSOLETE 			   &default_trace_show_source, "\
+// OBSOLETE Set display of source code with trace.", "\
+// OBSOLETE Show display of source code with trace.", "\
+// OBSOLETE When on source code is included in the d10v instruction trace display.", "\
+// OBSOLETE Display of source code with trace is %s.",
+// OBSOLETE 			   NULL, NULL, &setlist, &showlist);
+// OBSOLETE }