2002-08-06 Andrew Cagney <cagney@redhat.com>

* configure.tgt: Make arc-*-* obsolete.
* NEWS: Mention that arc-*-* has been identifed as obsolete.
* MAINTAINERS: Make arc-elf obsolete.
* arc-tdep.c: Make file obsolete.
* config/arc/arc.mt: Ditto.
* config/arc/tm-arc.h: Ditto.

7 files changed, 1089 insertions, 1081 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 80b4df3..0df93d6 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,12 @@
+2002-08-06  Andrew Cagney  <cagney@redhat.com>
+
+	* configure.tgt: Make arc-*-* obsolete.
+	* NEWS: Mention that arc-*-* has been identifed as obsolete.
+	* MAINTAINERS: Make arc-elf obsolete.
+	* arc-tdep.c: Make file obsolete.
+	* config/arc/arc.mt: Ditto.
+	* config/arc/tm-arc.h: Ditto.
+
 2002-08-05  Theodore A. Roth  <troth@verinet.com>
 
 	* gdb/avr-tdep.c(avr_skip_prologue): Fix to return the correct pc.
diff --git a/gdb/MAINTAINERS b/gdb/MAINTAINERS
index 78e1cf8..9965d1b 100644
--- a/gdb/MAINTAINERS
+++ b/gdb/MAINTAINERS
@@ -59,9 +59,7 @@ maintainer works with the native maintainer when resolving API issues.
 	alpha		--target=alpha-dec-osf4.0a -Werror
 			Maintenance only
 
-	arc		--target=arc-elf ,-Werror
-			Maintenance only
-			OBSOLETE candidate, not multi-arch
+	arc		(--target=arc-elf OBSOLETE)
 
 	arm		--target=arm-elf ,
 			Fernando Nasser		fnasser@redhat.com
diff --git a/gdb/NEWS b/gdb/NEWS
index e929bf8..fdfd033 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -59,6 +59,7 @@ Mitsubishi D30V					d30v-*-*
 OS/9000						i[34]86-*-os9k
 Fujitsu FR30					fr30-*-elf*
 Motorola Delta 88000 running Sys V		m88k-motorola-sysv  or  delta88
+Argonaut Risc Chip (ARC)			arc-*-*
 
 * OBSOLETE languages
 
diff --git a/gdb/arc-tdep.c b/gdb/arc-tdep.c
index 0614ebe..5c44915 100644
--- a/gdb/arc-tdep.c
+++ b/gdb/arc-tdep.c
@@ -1,738 +1,738 @@
-/* ARC target-dependent stuff.
-   Copyright 1995, 1996, 1999, 2000, 2001 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.  */
-
-#include "defs.h"
-#include "frame.h"
-#include "inferior.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "floatformat.h"
-#include "symtab.h"
-#include "gdbcmd.h"
-#include "regcache.h"
-#include "gdb_string.h"
-
-/* Local functions */
-
-static int arc_set_cpu_type (char *str);
-
-/* Current CPU, set with the "set cpu" command.  */
-static int arc_bfd_mach_type;
-char *arc_cpu_type;
-char *tmp_arc_cpu_type;
-
-/* Table of cpu names.  */
-struct
-  {
-    char *name;
-    int value;
-  }
-arc_cpu_type_table[] =
-{
-  { "arc5", bfd_mach_arc_5 },
-  { "arc6", bfd_mach_arc_6 },
-  { "arc7", bfd_mach_arc_7 },
-  { "arc8", bfd_mach_arc_8 },
-  {  NULL,  0 }
-};
-
-/* Used by simulator.  */
-int display_pipeline_p;
-int cpu_timer;
-/* This one must have the same type as used in the emulator.
-   It's currently an enum so this should be ok for now.  */
-int debug_pipeline_p;
-
-#define ARC_CALL_SAVED_REG(r) ((r) >= 16 && (r) < 24)
-
-#define OPMASK	0xf8000000
-
-/* Instruction field accessor macros.
-   See the Programmer's Reference Manual.  */
-#define X_OP(i) (((i) >> 27) & 0x1f)
-#define X_A(i) (((i) >> 21) & 0x3f)
-#define X_B(i) (((i) >> 15) & 0x3f)
-#define X_C(i) (((i) >> 9) & 0x3f)
-#define X_D(i) ((((i) & 0x1ff) ^ 0x100) - 0x100)
-#define X_L(i) (((((i) >> 5) & 0x3ffffc) ^ 0x200000) - 0x200000)
-#define X_N(i) (((i) >> 5) & 3)
-#define X_Q(i) ((i) & 0x1f)
-
-/* Return non-zero if X is a short immediate data indicator.  */
-#define SHIMM_P(x) ((x) == 61 || (x) == 63)
-
-/* Return non-zero if X is a "long" (32 bit) immediate data indicator.  */
-#define LIMM_P(x) ((x) == 62)
-
-/* Build a simple instruction.  */
-#define BUILD_INSN(op, a, b, c, d) \
-  ((((op) & 31) << 27) \
-   | (((a) & 63) << 21) \
-   | (((b) & 63) << 15) \
-   | (((c) & 63) << 9) \
-   | ((d) & 511))
-
-/* Codestream stuff.  */
-static void codestream_read (unsigned int *, int);
-static void codestream_seek (CORE_ADDR);
-static unsigned int codestream_fill (int);
-
-#define CODESTREAM_BUFSIZ 16
-static CORE_ADDR codestream_next_addr;
-static CORE_ADDR codestream_addr;
-/* FIXME assumes sizeof (int) == 32? */
-static unsigned int codestream_buf[CODESTREAM_BUFSIZ];
-static int codestream_off;
-static int codestream_cnt;
-
-#define codestream_tell() \
-  (codestream_addr + codestream_off * sizeof (codestream_buf[0]))
-#define codestream_peek() \
-  (codestream_cnt == 0 \
-   ? codestream_fill (1) \
-   : codestream_buf[codestream_off])
-#define codestream_get() \
-  (codestream_cnt-- == 0 \
-   ? codestream_fill (0) \
-   : codestream_buf[codestream_off++])
-
-static unsigned int
-codestream_fill (int peek_flag)
-{
-  codestream_addr = codestream_next_addr;
-  codestream_next_addr += CODESTREAM_BUFSIZ * sizeof (codestream_buf[0]);
-  codestream_off = 0;
-  codestream_cnt = CODESTREAM_BUFSIZ;
-  read_memory (codestream_addr, (char *) codestream_buf,
-	       CODESTREAM_BUFSIZ * sizeof (codestream_buf[0]));
-  /* FIXME: check return code?  */
-
-
-  /* Handle byte order differences -> convert to host byte ordering.  */
-  {
-    int i;
-    for (i = 0; i < CODESTREAM_BUFSIZ; i++)
-      codestream_buf[i] =
-	extract_unsigned_integer (&codestream_buf[i],
-				  sizeof (codestream_buf[i]));
-  }
-
-  if (peek_flag)
-    return codestream_peek ();
-  else
-    return codestream_get ();
-}
-
-static void
-codestream_seek (CORE_ADDR place)
-{
-  codestream_next_addr = place / CODESTREAM_BUFSIZ;
-  codestream_next_addr *= CODESTREAM_BUFSIZ;
-  codestream_cnt = 0;
-  codestream_fill (1);
-  while (codestream_tell () != place)
-    codestream_get ();
-}
-
-/* This function is currently unused but leave in for now.  */
-
-static void
-codestream_read (unsigned int *buf, int count)
-{
-  unsigned int *p;
-  int i;
-  p = buf;
-  for (i = 0; i < count; i++)
-    *p++ = codestream_get ();
-}
-
-/* Set up prologue scanning and return the first insn.  */
-
-static unsigned int
-setup_prologue_scan (CORE_ADDR pc)
-{
-  unsigned int insn;
-
-  codestream_seek (pc);
-  insn = codestream_get ();
-
-  return insn;
-}
-
-/*
- * Find & return amount a local space allocated, and advance codestream to
- * first register push (if any).
- * If entry sequence doesn't make sense, return -1, and leave 
- * codestream pointer random.
- */
-
-static long
-arc_get_frame_setup (CORE_ADDR pc)
-{
-  unsigned int insn;
-  /* Size of frame or -1 if unrecognizable prologue.  */
-  int frame_size = -1;
-  /* An initial "sub sp,sp,N" may or may not be for a stdarg fn.  */
-  int maybe_stdarg_decr = -1;
-
-  insn = setup_prologue_scan (pc);
-
-  /* The authority for what appears here is the home-grown ABI.
-     The most recent version is 1.2.  */
-
-  /* First insn may be "sub sp,sp,N" if stdarg fn.  */
-  if ((insn & BUILD_INSN (-1, -1, -1, -1, 0))
-      == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, SHIMM_REGNUM, 0))
-    {
-      maybe_stdarg_decr = X_D (insn);
-      insn = codestream_get ();
-    }
-
-  if ((insn & BUILD_INSN (-1, 0, -1, -1, -1))	/* st blink,[sp,4] */
-      == BUILD_INSN (2, 0, SP_REGNUM, BLINK_REGNUM, 4))
-    {
-      insn = codestream_get ();
-      /* Frame may not be necessary, even though blink is saved.
-         At least this is something we recognize.  */
-      frame_size = 0;
-    }
-
-  if ((insn & BUILD_INSN (-1, 0, -1, -1, -1))	/* st fp,[sp] */
-      == BUILD_INSN (2, 0, SP_REGNUM, FP_REGNUM, 0))
-    {
-      insn = codestream_get ();
-      if ((insn & BUILD_INSN (-1, -1, -1, -1, 0))
-	  != BUILD_INSN (12, FP_REGNUM, SP_REGNUM, SP_REGNUM, 0))
-	return -1;
-
-      /* Check for stack adjustment sub sp,sp,N.  */
-      insn = codestream_peek ();
-      if ((insn & BUILD_INSN (-1, -1, -1, 0, 0))
-	  == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, 0, 0))
-	{
-	  if (LIMM_P (X_C (insn)))
-	    frame_size = codestream_get ();
-	  else if (SHIMM_P (X_C (insn)))
-	    frame_size = X_D (insn);
-	  else
-	    return -1;
-	  if (frame_size < 0)
-	    return -1;
-
-	  codestream_get ();
-
-	  /* This sequence is used to get the address of the return
-	     buffer for a function that returns a structure.  */
-	  insn = codestream_peek ();
-	  if ((insn & OPMASK) == 0x60000000)
-	    codestream_get ();
-	}
-      /* Frameless fn.  */
-      else
-	{
-	  frame_size = 0;
-	}
-    }
-
-  /* If we found a "sub sp,sp,N" and nothing else, it may or may not be a
-     stdarg fn.  The stdarg decrement is not treated as part of the frame size,
-     so we have a dilemma: what do we return?  For now, if we get a
-     "sub sp,sp,N" and nothing else assume this isn't a stdarg fn.  One way
-     to fix this completely would be to add a bit to the function descriptor
-     that says the function is a stdarg function.  */
-
-  if (frame_size < 0 && maybe_stdarg_decr > 0)
-    return maybe_stdarg_decr;
-  return frame_size;
-}
-
-/* Given a pc value, skip it forward past the function prologue by
-   disassembling instructions that appear to be a prologue.
-
-   If FRAMELESS_P is set, we are only testing to see if the function
-   is frameless.  If it is a frameless function, return PC unchanged.
-   This allows a quicker answer.  */
-
-CORE_ADDR
-arc_skip_prologue (CORE_ADDR pc, int frameless_p)
-{
-  unsigned int insn;
-  int i, frame_size;
-
-  if ((frame_size = arc_get_frame_setup (pc)) < 0)
-    return (pc);
-
-  if (frameless_p)
-    return frame_size == 0 ? pc : codestream_tell ();
-
-  /* Skip over register saves.  */
-  for (i = 0; i < 8; i++)
-    {
-      insn = codestream_peek ();
-      if ((insn & BUILD_INSN (-1, 0, -1, 0, 0))
-	  != BUILD_INSN (2, 0, SP_REGNUM, 0, 0))
-	break;			/* not st insn */
-      if (!ARC_CALL_SAVED_REG (X_C (insn)))
-	break;
-      codestream_get ();
-    }
-
-  return codestream_tell ();
-}
-
-/* Is the prologue at PC frameless?  */
-
-int
-arc_prologue_frameless_p (CORE_ADDR pc)
-{
-  return (pc == arc_skip_prologue (pc, 1));
-}
-
-/* Return the return address for a frame.
-   This is used to implement FRAME_SAVED_PC.
-   This is taken from frameless_look_for_prologue.  */
-
-CORE_ADDR
-arc_frame_saved_pc (struct frame_info *frame)
-{
-  CORE_ADDR func_start;
-  unsigned int insn;
-
-  func_start = get_pc_function_start (frame->pc) + FUNCTION_START_OFFSET;
-  if (func_start == 0)
-    {
-      /* Best guess.  */
-      return ARC_PC_TO_REAL_ADDRESS (read_memory_integer (FRAME_FP (frame) + 4, 4));
-    }
-
-  /* The authority for what appears here is the home-grown ABI.
-     The most recent version is 1.2.  */
-
-  insn = setup_prologue_scan (func_start);
-
-  /* First insn may be "sub sp,sp,N" if stdarg fn.  */
-  if ((insn & BUILD_INSN (-1, -1, -1, -1, 0))
-      == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, SHIMM_REGNUM, 0))
-    insn = codestream_get ();
-
-  /* If the next insn is "st blink,[sp,4]" we can get blink from there.
-     Otherwise this is a leaf function and we can use blink.  Note that
-     this still allows for the case where a leaf function saves/clobbers/
-     restores blink.  */
-
-  if ((insn & BUILD_INSN (-1, 0, -1, -1, -1))	/* st blink,[sp,4] */
-      != BUILD_INSN (2, 0, SP_REGNUM, BLINK_REGNUM, 4))
-    return ARC_PC_TO_REAL_ADDRESS (read_register (BLINK_REGNUM));
-  else
-    return ARC_PC_TO_REAL_ADDRESS (read_memory_integer (FRAME_FP (frame) + 4, 4));
-}
-
-/*
- * Parse the first few instructions of the function to see
- * what registers were stored.
- *
- * The startup sequence can be at the start of the function.
- * 'st blink,[sp+4], st fp,[sp], mov fp,sp' 
- *
- * Local space is allocated just below by sub sp,sp,nnn.
- * Next, the registers used by this function are stored (as offsets from sp).
- */
-
-void
-frame_find_saved_regs (struct frame_info *fip, struct frame_saved_regs *fsrp)
-{
-  long locals;
-  unsigned int insn;
-  CORE_ADDR dummy_bottom;
-  CORE_ADDR adr;
-  int i, regnum, offset;
-
-  memset (fsrp, 0, sizeof *fsrp);
-
-  /* If frame is the end of a dummy, compute where the beginning would be.  */
-  dummy_bottom = fip->frame - 4 - REGISTER_BYTES - CALL_DUMMY_LENGTH;
-
-  /* Check if the PC is in the stack, in a dummy frame.  */
-  if (dummy_bottom <= fip->pc && fip->pc <= fip->frame)
-    {
-      /* all regs were saved by push_call_dummy () */
-      adr = fip->frame;
-      for (i = 0; i < NUM_REGS; i++)
-	{
-	  adr -= REGISTER_RAW_SIZE (i);
-	  fsrp->regs[i] = adr;
-	}
-      return;
-    }
-
-  locals = arc_get_frame_setup (get_pc_function_start (fip->pc));
-
-  if (locals >= 0)
-    {
-      /* Set `adr' to the value of `sp'.  */
-      adr = fip->frame - locals;
-      for (i = 0; i < 8; i++)
-	{
-	  insn = codestream_get ();
-	  if ((insn & BUILD_INSN (-1, 0, -1, 0, 0))
-	      != BUILD_INSN (2, 0, SP_REGNUM, 0, 0))
-	    break;
-	  regnum = X_C (insn);
-	  offset = X_D (insn);
-	  fsrp->regs[regnum] = adr + offset;
-	}
-    }
-
-  fsrp->regs[PC_REGNUM] = fip->frame + 4;
-  fsrp->regs[FP_REGNUM] = fip->frame;
-}
-
-void
-arc_push_dummy_frame (void)
-{
-  CORE_ADDR sp = read_register (SP_REGNUM);
-  int regnum;
-  char regbuf[MAX_REGISTER_RAW_SIZE];
-
-  read_register_gen (PC_REGNUM, regbuf);
-  write_memory (sp + 4, regbuf, REGISTER_SIZE);
-  read_register_gen (FP_REGNUM, regbuf);
-  write_memory (sp, regbuf, REGISTER_SIZE);
-  write_register (FP_REGNUM, sp);
-  for (regnum = 0; regnum < NUM_REGS; regnum++)
-    {
-      read_register_gen (regnum, regbuf);
-      sp = push_bytes (sp, regbuf, REGISTER_RAW_SIZE (regnum));
-    }
-  sp += (2 * REGISTER_SIZE);
-  write_register (SP_REGNUM, sp);
-}
-
-void
-arc_pop_frame (void)
-{
-  struct frame_info *frame = get_current_frame ();
-  CORE_ADDR fp;
-  int regnum;
-  struct frame_saved_regs fsr;
-  char regbuf[MAX_REGISTER_RAW_SIZE];
-
-  fp = FRAME_FP (frame);
-  get_frame_saved_regs (frame, &fsr);
-  for (regnum = 0; regnum < NUM_REGS; regnum++)
-    {
-      CORE_ADDR adr;
-      adr = fsr.regs[regnum];
-      if (adr)
-	{
-	  read_memory (adr, regbuf, REGISTER_RAW_SIZE (regnum));
-	  write_register_bytes (REGISTER_BYTE (regnum), regbuf,
-				REGISTER_RAW_SIZE (regnum));
-	}
-    }
-  write_register (FP_REGNUM, read_memory_integer (fp, 4));
-  write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
-  write_register (SP_REGNUM, fp + 8);
-  flush_cached_frames ();
-}
-
-/* Simulate single-step.  */
-
-typedef enum
-{
-  NORMAL4,			/* a normal 4 byte insn */
-  NORMAL8,			/* a normal 8 byte insn */
-  BRANCH4,			/* a 4 byte branch insn, including ones without delay slots */
-  BRANCH8,			/* an 8 byte branch insn, including ones with delay slots */
-}
-insn_type;
-
-/* Return the type of INSN and store in TARGET the destination address of a
-   branch if this is one.  */
-/* ??? Need to verify all cases are properly handled.  */
-
-static insn_type
-get_insn_type (unsigned long insn, CORE_ADDR pc, CORE_ADDR *target)
-{
-  unsigned long limm;
-
-  switch (insn >> 27)
-    {
-    case 0:
-    case 1:
-    case 2:			/* load/store insns */
-      if (LIMM_P (X_A (insn))
-	  || LIMM_P (X_B (insn))
-	  || LIMM_P (X_C (insn)))
-	return NORMAL8;
-      return NORMAL4;
-    case 4:
-    case 5:
-    case 6:			/* branch insns */
-      *target = pc + 4 + X_L (insn);
-      /* ??? It isn't clear that this is always the right answer.
-         The problem occurs when the next insn is an 8 byte insn.  If the
-         branch is conditional there's no worry as there shouldn't be an 8
-         byte insn following.  The programmer may be cheating if s/he knows
-         the branch will never be taken, but we don't deal with that.
-         Note that the programmer is also allowed to play games by putting
-         an insn with long immediate data in the delay slot and then duplicate
-         the long immediate data at the branch target.  Ugh!  */
-      if (X_N (insn) == 0)
-	return BRANCH4;
-      return BRANCH8;
-    case 7:			/* jump insns */
-      if (LIMM_P (X_B (insn)))
-	{
-	  limm = read_memory_integer (pc + 4, 4);
-	  *target = ARC_PC_TO_REAL_ADDRESS (limm);
-	  return BRANCH8;
-	}
-      if (SHIMM_P (X_B (insn)))
-	*target = ARC_PC_TO_REAL_ADDRESS (X_D (insn));
-      else
-	*target = ARC_PC_TO_REAL_ADDRESS (read_register (X_B (insn)));
-      if (X_Q (insn) == 0 && X_N (insn) == 0)
-	return BRANCH4;
-      return BRANCH8;
-    default:			/* arithmetic insns, etc. */
-      if (LIMM_P (X_A (insn))
-	  || LIMM_P (X_B (insn))
-	  || LIMM_P (X_C (insn)))
-	return NORMAL8;
-      return NORMAL4;
-    }
-}
-
-/* single_step() is called just before we want to resume the inferior, if we
-   want to single-step it but there is no hardware or kernel single-step
-   support.  We find all the possible targets of the coming instruction and
-   breakpoint them.
-
-   single_step is also called just after the inferior stops.  If we had
-   set up a simulated single-step, we undo our damage.  */
-
-void
-arc_software_single_step (enum target_signal ignore,	/* sig but we don't need it */
-			  int insert_breakpoints_p)
-{
-  static CORE_ADDR next_pc, target;
-  static int brktrg_p;
-  typedef char binsn_quantum[BREAKPOINT_MAX];
-  static binsn_quantum break_mem[2];
-
-  if (insert_breakpoints_p)
-    {
-      insn_type type;
-      CORE_ADDR pc;
-      unsigned long insn;
-
-      pc = read_register (PC_REGNUM);
-      insn = read_memory_integer (pc, 4);
-      type = get_insn_type (insn, pc, &target);
-
-      /* Always set a breakpoint for the insn after the branch.  */
-      next_pc = pc + ((type == NORMAL8 || type == BRANCH8) ? 8 : 4);
-      target_insert_breakpoint (next_pc, break_mem[0]);
-
-      brktrg_p = 0;
-
-      if ((type == BRANCH4 || type == BRANCH8)
-      /* Watch out for branches to the following location.
-         We just stored a breakpoint there and another call to
-         target_insert_breakpoint will think the real insn is the
-         breakpoint we just stored there.  */
-	  && target != next_pc)
-	{
-	  brktrg_p = 1;
-	  target_insert_breakpoint (target, break_mem[1]);
-	}
-
-    }
-  else
-    {
-      /* Remove breakpoints.  */
-      target_remove_breakpoint (next_pc, break_mem[0]);
-
-      if (brktrg_p)
-	target_remove_breakpoint (target, break_mem[1]);
-
-      /* Fix the pc.  */
-      stop_pc -= DECR_PC_AFTER_BREAK;
-      write_pc (stop_pc);
-    }
-}
-
-/* Because of Multi-arch, GET_LONGJMP_TARGET is always defined.  So test
-   for a definition of JB_PC.  */
-#ifdef JB_PC
-/* Figure out where the longjmp will land.  Slurp the args out of the stack.
-   We expect the first arg to be a pointer to the jmp_buf structure from which
-   we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
-   This routine returns true on success. */
-
-int
-get_longjmp_target (CORE_ADDR *pc)
-{
-  char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
-  CORE_ADDR sp, jb_addr;
-
-  sp = read_register (SP_REGNUM);
-
-  if (target_read_memory (sp + SP_ARG0,		/* Offset of first arg on stack */
-			  buf,
-			  TARGET_PTR_BIT / TARGET_CHAR_BIT))
-    return 0;
-
-  jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
-
-  if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
-			  TARGET_PTR_BIT / TARGET_CHAR_BIT))
-    return 0;
-
-  *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
-
-  return 1;
-}
-#endif /* GET_LONGJMP_TARGET */
-
-/* Disassemble one instruction.  */
-
-static int
-arc_print_insn (bfd_vma vma, disassemble_info *info)
-{
-  static int current_mach;
-  static int current_endian;
-  static disassembler_ftype current_disasm;
-
-  if (current_disasm == NULL
-      || arc_bfd_mach_type != current_mach
-      || TARGET_BYTE_ORDER != current_endian)
-    {
-      current_mach = arc_bfd_mach_type;
-      current_endian = TARGET_BYTE_ORDER;
-      current_disasm = arc_get_disassembler (NULL);
-    }
-
-  return (*current_disasm) (vma, info);
-}
-
-/* Command to set cpu type.  */
-
-void
-arc_set_cpu_type_command (char *args, int from_tty)
-{
-  int i;
-
-  if (tmp_arc_cpu_type == NULL || *tmp_arc_cpu_type == '\0')
-    {
-      printf_unfiltered ("The known ARC cpu types are as follows:\n");
-      for (i = 0; arc_cpu_type_table[i].name != NULL; ++i)
-	printf_unfiltered ("%s\n", arc_cpu_type_table[i].name);
-
-      /* Restore the value.  */
-      tmp_arc_cpu_type = xstrdup (arc_cpu_type);
-
-      return;
-    }
-
-  if (!arc_set_cpu_type (tmp_arc_cpu_type))
-    {
-      error ("Unknown cpu type `%s'.", tmp_arc_cpu_type);
-      /* Restore its value.  */
-      tmp_arc_cpu_type = xstrdup (arc_cpu_type);
-    }
-}
-
-static void
-arc_show_cpu_type_command (char *args, int from_tty)
-{
-}
-
-/* Modify the actual cpu type.
-   Result is a boolean indicating success.  */
-
-static int
-arc_set_cpu_type (char *str)
-{
-  int i, j;
-
-  if (str == NULL)
-    return 0;
-
-  for (i = 0; arc_cpu_type_table[i].name != NULL; ++i)
-    {
-      if (strcasecmp (str, arc_cpu_type_table[i].name) == 0)
-	{
-	  arc_cpu_type = str;
-	  arc_bfd_mach_type = arc_cpu_type_table[i].value;
-	  return 1;
-	}
-    }
-
-  return 0;
-}
-
-void
-_initialize_arc_tdep (void)
-{
-  struct cmd_list_element *c;
-
-  c = add_set_cmd ("cpu", class_support, var_string_noescape,
-		   (char *) &tmp_arc_cpu_type,
-		   "Set the type of ARC cpu in use.\n\
-This command has two purposes.  In a multi-cpu system it lets one\n\
-change the cpu being debugged.  It also gives one access to\n\
-cpu-type-specific registers and recognize cpu-type-specific instructions.\
-",
-		   &setlist);
-  set_cmd_cfunc (c, arc_set_cpu_type_command);
-  c = add_show_from_set (c, &showlist);
-  set_cmd_cfunc (c, arc_show_cpu_type_command);
-
-  /* We have to use xstrdup() here because the `set' command frees it
-     before setting a new value.  */
-  tmp_arc_cpu_type = xstrdup (DEFAULT_ARC_CPU_TYPE);
-  arc_set_cpu_type (tmp_arc_cpu_type);
-
-  c = add_set_cmd ("displaypipeline", class_support, var_zinteger,
-		   (char *) &display_pipeline_p,
-		   "Set pipeline display (simulator only).\n\
-When enabled, the state of the pipeline after each cycle is displayed.",
-		   &setlist);
-  c = add_show_from_set (c, &showlist);
-
-  c = add_set_cmd ("debugpipeline", class_support, var_zinteger,
-		   (char *) &debug_pipeline_p,
-		   "Set pipeline debug display (simulator only).\n\
-When enabled, debugging information about the pipeline is displayed.",
-		   &setlist);
-  c = add_show_from_set (c, &showlist);
-
-  c = add_set_cmd ("cputimer", class_support, var_zinteger,
-		   (char *) &cpu_timer,
-		   "Set maximum cycle count (simulator only).\n\
-Control will return to gdb if the timer expires.\n\
-A negative value disables the timer.",
-		   &setlist);
-  c = add_show_from_set (c, &showlist);
-
-  tm_print_insn = arc_print_insn;
-}
+// OBSOLETE /* ARC target-dependent stuff.
+// OBSOLETE    Copyright 1995, 1996, 1999, 2000, 2001 Free Software 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 #include "defs.h"
+// OBSOLETE #include "frame.h"
+// OBSOLETE #include "inferior.h"
+// OBSOLETE #include "gdbcore.h"
+// OBSOLETE #include "target.h"
+// OBSOLETE #include "floatformat.h"
+// OBSOLETE #include "symtab.h"
+// OBSOLETE #include "gdbcmd.h"
+// OBSOLETE #include "regcache.h"
+// OBSOLETE #include "gdb_string.h"
+// OBSOLETE 
+// OBSOLETE /* Local functions */
+// OBSOLETE 
+// OBSOLETE static int arc_set_cpu_type (char *str);
+// OBSOLETE 
+// OBSOLETE /* Current CPU, set with the "set cpu" command.  */
+// OBSOLETE static int arc_bfd_mach_type;
+// OBSOLETE char *arc_cpu_type;
+// OBSOLETE char *tmp_arc_cpu_type;
+// OBSOLETE 
+// OBSOLETE /* Table of cpu names.  */
+// OBSOLETE struct
+// OBSOLETE   {
+// OBSOLETE     char *name;
+// OBSOLETE     int value;
+// OBSOLETE   }
+// OBSOLETE arc_cpu_type_table[] =
+// OBSOLETE {
+// OBSOLETE   { "arc5", bfd_mach_arc_5 },
+// OBSOLETE   { "arc6", bfd_mach_arc_6 },
+// OBSOLETE   { "arc7", bfd_mach_arc_7 },
+// OBSOLETE   { "arc8", bfd_mach_arc_8 },
+// OBSOLETE   {  NULL,  0 }
+// OBSOLETE };
+// OBSOLETE 
+// OBSOLETE /* Used by simulator.  */
+// OBSOLETE int display_pipeline_p;
+// OBSOLETE int cpu_timer;
+// OBSOLETE /* This one must have the same type as used in the emulator.
+// OBSOLETE    It's currently an enum so this should be ok for now.  */
+// OBSOLETE int debug_pipeline_p;
+// OBSOLETE 
+// OBSOLETE #define ARC_CALL_SAVED_REG(r) ((r) >= 16 && (r) < 24)
+// OBSOLETE 
+// OBSOLETE #define OPMASK	0xf8000000
+// OBSOLETE 
+// OBSOLETE /* Instruction field accessor macros.
+// OBSOLETE    See the Programmer's Reference Manual.  */
+// OBSOLETE #define X_OP(i) (((i) >> 27) & 0x1f)
+// OBSOLETE #define X_A(i) (((i) >> 21) & 0x3f)
+// OBSOLETE #define X_B(i) (((i) >> 15) & 0x3f)
+// OBSOLETE #define X_C(i) (((i) >> 9) & 0x3f)
+// OBSOLETE #define X_D(i) ((((i) & 0x1ff) ^ 0x100) - 0x100)
+// OBSOLETE #define X_L(i) (((((i) >> 5) & 0x3ffffc) ^ 0x200000) - 0x200000)
+// OBSOLETE #define X_N(i) (((i) >> 5) & 3)
+// OBSOLETE #define X_Q(i) ((i) & 0x1f)
+// OBSOLETE 
+// OBSOLETE /* Return non-zero if X is a short immediate data indicator.  */
+// OBSOLETE #define SHIMM_P(x) ((x) == 61 || (x) == 63)
+// OBSOLETE 
+// OBSOLETE /* Return non-zero if X is a "long" (32 bit) immediate data indicator.  */
+// OBSOLETE #define LIMM_P(x) ((x) == 62)
+// OBSOLETE 
+// OBSOLETE /* Build a simple instruction.  */
+// OBSOLETE #define BUILD_INSN(op, a, b, c, d) \
+// OBSOLETE   ((((op) & 31) << 27) \
+// OBSOLETE    | (((a) & 63) << 21) \
+// OBSOLETE    | (((b) & 63) << 15) \
+// OBSOLETE    | (((c) & 63) << 9) \
+// OBSOLETE    | ((d) & 511))
+// OBSOLETE 
+// OBSOLETE /* Codestream stuff.  */
+// OBSOLETE static void codestream_read (unsigned int *, int);
+// OBSOLETE static void codestream_seek (CORE_ADDR);
+// OBSOLETE static unsigned int codestream_fill (int);
+// OBSOLETE 
+// OBSOLETE #define CODESTREAM_BUFSIZ 16
+// OBSOLETE static CORE_ADDR codestream_next_addr;
+// OBSOLETE static CORE_ADDR codestream_addr;
+// OBSOLETE /* FIXME assumes sizeof (int) == 32? */
+// OBSOLETE static unsigned int codestream_buf[CODESTREAM_BUFSIZ];
+// OBSOLETE static int codestream_off;
+// OBSOLETE static int codestream_cnt;
+// OBSOLETE 
+// OBSOLETE #define codestream_tell() \
+// OBSOLETE   (codestream_addr + codestream_off * sizeof (codestream_buf[0]))
+// OBSOLETE #define codestream_peek() \
+// OBSOLETE   (codestream_cnt == 0 \
+// OBSOLETE    ? codestream_fill (1) \
+// OBSOLETE    : codestream_buf[codestream_off])
+// OBSOLETE #define codestream_get() \
+// OBSOLETE   (codestream_cnt-- == 0 \
+// OBSOLETE    ? codestream_fill (0) \
+// OBSOLETE    : codestream_buf[codestream_off++])
+// OBSOLETE 
+// OBSOLETE static unsigned int
+// OBSOLETE codestream_fill (int peek_flag)
+// OBSOLETE {
+// OBSOLETE   codestream_addr = codestream_next_addr;
+// OBSOLETE   codestream_next_addr += CODESTREAM_BUFSIZ * sizeof (codestream_buf[0]);
+// OBSOLETE   codestream_off = 0;
+// OBSOLETE   codestream_cnt = CODESTREAM_BUFSIZ;
+// OBSOLETE   read_memory (codestream_addr, (char *) codestream_buf,
+// OBSOLETE 	       CODESTREAM_BUFSIZ * sizeof (codestream_buf[0]));
+// OBSOLETE   /* FIXME: check return code?  */
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE   /* Handle byte order differences -> convert to host byte ordering.  */
+// OBSOLETE   {
+// OBSOLETE     int i;
+// OBSOLETE     for (i = 0; i < CODESTREAM_BUFSIZ; i++)
+// OBSOLETE       codestream_buf[i] =
+// OBSOLETE 	extract_unsigned_integer (&codestream_buf[i],
+// OBSOLETE 				  sizeof (codestream_buf[i]));
+// OBSOLETE   }
+// OBSOLETE 
+// OBSOLETE   if (peek_flag)
+// OBSOLETE     return codestream_peek ();
+// OBSOLETE   else
+// OBSOLETE     return codestream_get ();
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE codestream_seek (CORE_ADDR place)
+// OBSOLETE {
+// OBSOLETE   codestream_next_addr = place / CODESTREAM_BUFSIZ;
+// OBSOLETE   codestream_next_addr *= CODESTREAM_BUFSIZ;
+// OBSOLETE   codestream_cnt = 0;
+// OBSOLETE   codestream_fill (1);
+// OBSOLETE   while (codestream_tell () != place)
+// OBSOLETE     codestream_get ();
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* This function is currently unused but leave in for now.  */
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE codestream_read (unsigned int *buf, int count)
+// OBSOLETE {
+// OBSOLETE   unsigned int *p;
+// OBSOLETE   int i;
+// OBSOLETE   p = buf;
+// OBSOLETE   for (i = 0; i < count; i++)
+// OBSOLETE     *p++ = codestream_get ();
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Set up prologue scanning and return the first insn.  */
+// OBSOLETE 
+// OBSOLETE static unsigned int
+// OBSOLETE setup_prologue_scan (CORE_ADDR pc)
+// OBSOLETE {
+// OBSOLETE   unsigned int insn;
+// OBSOLETE 
+// OBSOLETE   codestream_seek (pc);
+// OBSOLETE   insn = codestream_get ();
+// OBSOLETE 
+// OBSOLETE   return insn;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /*
+// OBSOLETE  * Find & return amount a local space allocated, and advance codestream to
+// OBSOLETE  * first register push (if any).
+// OBSOLETE  * If entry sequence doesn't make sense, return -1, and leave 
+// OBSOLETE  * codestream pointer random.
+// OBSOLETE  */
+// OBSOLETE 
+// OBSOLETE static long
+// OBSOLETE arc_get_frame_setup (CORE_ADDR pc)
+// OBSOLETE {
+// OBSOLETE   unsigned int insn;
+// OBSOLETE   /* Size of frame or -1 if unrecognizable prologue.  */
+// OBSOLETE   int frame_size = -1;
+// OBSOLETE   /* An initial "sub sp,sp,N" may or may not be for a stdarg fn.  */
+// OBSOLETE   int maybe_stdarg_decr = -1;
+// OBSOLETE 
+// OBSOLETE   insn = setup_prologue_scan (pc);
+// OBSOLETE 
+// OBSOLETE   /* The authority for what appears here is the home-grown ABI.
+// OBSOLETE      The most recent version is 1.2.  */
+// OBSOLETE 
+// OBSOLETE   /* First insn may be "sub sp,sp,N" if stdarg fn.  */
+// OBSOLETE   if ((insn & BUILD_INSN (-1, -1, -1, -1, 0))
+// OBSOLETE       == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, SHIMM_REGNUM, 0))
+// OBSOLETE     {
+// OBSOLETE       maybe_stdarg_decr = X_D (insn);
+// OBSOLETE       insn = codestream_get ();
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   if ((insn & BUILD_INSN (-1, 0, -1, -1, -1))	/* st blink,[sp,4] */
+// OBSOLETE       == BUILD_INSN (2, 0, SP_REGNUM, BLINK_REGNUM, 4))
+// OBSOLETE     {
+// OBSOLETE       insn = codestream_get ();
+// OBSOLETE       /* Frame may not be necessary, even though blink is saved.
+// OBSOLETE          At least this is something we recognize.  */
+// OBSOLETE       frame_size = 0;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   if ((insn & BUILD_INSN (-1, 0, -1, -1, -1))	/* st fp,[sp] */
+// OBSOLETE       == BUILD_INSN (2, 0, SP_REGNUM, FP_REGNUM, 0))
+// OBSOLETE     {
+// OBSOLETE       insn = codestream_get ();
+// OBSOLETE       if ((insn & BUILD_INSN (-1, -1, -1, -1, 0))
+// OBSOLETE 	  != BUILD_INSN (12, FP_REGNUM, SP_REGNUM, SP_REGNUM, 0))
+// OBSOLETE 	return -1;
+// OBSOLETE 
+// OBSOLETE       /* Check for stack adjustment sub sp,sp,N.  */
+// OBSOLETE       insn = codestream_peek ();
+// OBSOLETE       if ((insn & BUILD_INSN (-1, -1, -1, 0, 0))
+// OBSOLETE 	  == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, 0, 0))
+// OBSOLETE 	{
+// OBSOLETE 	  if (LIMM_P (X_C (insn)))
+// OBSOLETE 	    frame_size = codestream_get ();
+// OBSOLETE 	  else if (SHIMM_P (X_C (insn)))
+// OBSOLETE 	    frame_size = X_D (insn);
+// OBSOLETE 	  else
+// OBSOLETE 	    return -1;
+// OBSOLETE 	  if (frame_size < 0)
+// OBSOLETE 	    return -1;
+// OBSOLETE 
+// OBSOLETE 	  codestream_get ();
+// OBSOLETE 
+// OBSOLETE 	  /* This sequence is used to get the address of the return
+// OBSOLETE 	     buffer for a function that returns a structure.  */
+// OBSOLETE 	  insn = codestream_peek ();
+// OBSOLETE 	  if ((insn & OPMASK) == 0x60000000)
+// OBSOLETE 	    codestream_get ();
+// OBSOLETE 	}
+// OBSOLETE       /* Frameless fn.  */
+// OBSOLETE       else
+// OBSOLETE 	{
+// OBSOLETE 	  frame_size = 0;
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* If we found a "sub sp,sp,N" and nothing else, it may or may not be a
+// OBSOLETE      stdarg fn.  The stdarg decrement is not treated as part of the frame size,
+// OBSOLETE      so we have a dilemma: what do we return?  For now, if we get a
+// OBSOLETE      "sub sp,sp,N" and nothing else assume this isn't a stdarg fn.  One way
+// OBSOLETE      to fix this completely would be to add a bit to the function descriptor
+// OBSOLETE      that says the function is a stdarg function.  */
+// OBSOLETE 
+// OBSOLETE   if (frame_size < 0 && maybe_stdarg_decr > 0)
+// OBSOLETE     return maybe_stdarg_decr;
+// OBSOLETE   return frame_size;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Given a pc value, skip it forward past the function prologue by
+// OBSOLETE    disassembling instructions that appear to be a prologue.
+// OBSOLETE 
+// OBSOLETE    If FRAMELESS_P is set, we are only testing to see if the function
+// OBSOLETE    is frameless.  If it is a frameless function, return PC unchanged.
+// OBSOLETE    This allows a quicker answer.  */
+// OBSOLETE 
+// OBSOLETE CORE_ADDR
+// OBSOLETE arc_skip_prologue (CORE_ADDR pc, int frameless_p)
+// OBSOLETE {
+// OBSOLETE   unsigned int insn;
+// OBSOLETE   int i, frame_size;
+// OBSOLETE 
+// OBSOLETE   if ((frame_size = arc_get_frame_setup (pc)) < 0)
+// OBSOLETE     return (pc);
+// OBSOLETE 
+// OBSOLETE   if (frameless_p)
+// OBSOLETE     return frame_size == 0 ? pc : codestream_tell ();
+// OBSOLETE 
+// OBSOLETE   /* Skip over register saves.  */
+// OBSOLETE   for (i = 0; i < 8; i++)
+// OBSOLETE     {
+// OBSOLETE       insn = codestream_peek ();
+// OBSOLETE       if ((insn & BUILD_INSN (-1, 0, -1, 0, 0))
+// OBSOLETE 	  != BUILD_INSN (2, 0, SP_REGNUM, 0, 0))
+// OBSOLETE 	break;			/* not st insn */
+// OBSOLETE       if (!ARC_CALL_SAVED_REG (X_C (insn)))
+// OBSOLETE 	break;
+// OBSOLETE       codestream_get ();
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   return codestream_tell ();
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Is the prologue at PC frameless?  */
+// OBSOLETE 
+// OBSOLETE int
+// OBSOLETE arc_prologue_frameless_p (CORE_ADDR pc)
+// OBSOLETE {
+// OBSOLETE   return (pc == arc_skip_prologue (pc, 1));
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Return the return address for a frame.
+// OBSOLETE    This is used to implement FRAME_SAVED_PC.
+// OBSOLETE    This is taken from frameless_look_for_prologue.  */
+// OBSOLETE 
+// OBSOLETE CORE_ADDR
+// OBSOLETE arc_frame_saved_pc (struct frame_info *frame)
+// OBSOLETE {
+// OBSOLETE   CORE_ADDR func_start;
+// OBSOLETE   unsigned int insn;
+// OBSOLETE 
+// OBSOLETE   func_start = get_pc_function_start (frame->pc) + FUNCTION_START_OFFSET;
+// OBSOLETE   if (func_start == 0)
+// OBSOLETE     {
+// OBSOLETE       /* Best guess.  */
+// OBSOLETE       return ARC_PC_TO_REAL_ADDRESS (read_memory_integer (FRAME_FP (frame) + 4, 4));
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   /* The authority for what appears here is the home-grown ABI.
+// OBSOLETE      The most recent version is 1.2.  */
+// OBSOLETE 
+// OBSOLETE   insn = setup_prologue_scan (func_start);
+// OBSOLETE 
+// OBSOLETE   /* First insn may be "sub sp,sp,N" if stdarg fn.  */
+// OBSOLETE   if ((insn & BUILD_INSN (-1, -1, -1, -1, 0))
+// OBSOLETE       == BUILD_INSN (10, SP_REGNUM, SP_REGNUM, SHIMM_REGNUM, 0))
+// OBSOLETE     insn = codestream_get ();
+// OBSOLETE 
+// OBSOLETE   /* If the next insn is "st blink,[sp,4]" we can get blink from there.
+// OBSOLETE      Otherwise this is a leaf function and we can use blink.  Note that
+// OBSOLETE      this still allows for the case where a leaf function saves/clobbers/
+// OBSOLETE      restores blink.  */
+// OBSOLETE 
+// OBSOLETE   if ((insn & BUILD_INSN (-1, 0, -1, -1, -1))	/* st blink,[sp,4] */
+// OBSOLETE       != BUILD_INSN (2, 0, SP_REGNUM, BLINK_REGNUM, 4))
+// OBSOLETE     return ARC_PC_TO_REAL_ADDRESS (read_register (BLINK_REGNUM));
+// OBSOLETE   else
+// OBSOLETE     return ARC_PC_TO_REAL_ADDRESS (read_memory_integer (FRAME_FP (frame) + 4, 4));
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /*
+// OBSOLETE  * Parse the first few instructions of the function to see
+// OBSOLETE  * what registers were stored.
+// OBSOLETE  *
+// OBSOLETE  * The startup sequence can be at the start of the function.
+// OBSOLETE  * 'st blink,[sp+4], st fp,[sp], mov fp,sp' 
+// OBSOLETE  *
+// OBSOLETE  * Local space is allocated just below by sub sp,sp,nnn.
+// OBSOLETE  * Next, the registers used by this function are stored (as offsets from sp).
+// OBSOLETE  */
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE frame_find_saved_regs (struct frame_info *fip, struct frame_saved_regs *fsrp)
+// OBSOLETE {
+// OBSOLETE   long locals;
+// OBSOLETE   unsigned int insn;
+// OBSOLETE   CORE_ADDR dummy_bottom;
+// OBSOLETE   CORE_ADDR adr;
+// OBSOLETE   int i, regnum, offset;
+// OBSOLETE 
+// OBSOLETE   memset (fsrp, 0, sizeof *fsrp);
+// OBSOLETE 
+// OBSOLETE   /* If frame is the end of a dummy, compute where the beginning would be.  */
+// OBSOLETE   dummy_bottom = fip->frame - 4 - REGISTER_BYTES - CALL_DUMMY_LENGTH;
+// OBSOLETE 
+// OBSOLETE   /* Check if the PC is in the stack, in a dummy frame.  */
+// OBSOLETE   if (dummy_bottom <= fip->pc && fip->pc <= fip->frame)
+// OBSOLETE     {
+// OBSOLETE       /* all regs were saved by push_call_dummy () */
+// OBSOLETE       adr = fip->frame;
+// OBSOLETE       for (i = 0; i < NUM_REGS; i++)
+// OBSOLETE 	{
+// OBSOLETE 	  adr -= REGISTER_RAW_SIZE (i);
+// OBSOLETE 	  fsrp->regs[i] = adr;
+// OBSOLETE 	}
+// OBSOLETE       return;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   locals = arc_get_frame_setup (get_pc_function_start (fip->pc));
+// OBSOLETE 
+// OBSOLETE   if (locals >= 0)
+// OBSOLETE     {
+// OBSOLETE       /* Set `adr' to the value of `sp'.  */
+// OBSOLETE       adr = fip->frame - locals;
+// OBSOLETE       for (i = 0; i < 8; i++)
+// OBSOLETE 	{
+// OBSOLETE 	  insn = codestream_get ();
+// OBSOLETE 	  if ((insn & BUILD_INSN (-1, 0, -1, 0, 0))
+// OBSOLETE 	      != BUILD_INSN (2, 0, SP_REGNUM, 0, 0))
+// OBSOLETE 	    break;
+// OBSOLETE 	  regnum = X_C (insn);
+// OBSOLETE 	  offset = X_D (insn);
+// OBSOLETE 	  fsrp->regs[regnum] = adr + offset;
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   fsrp->regs[PC_REGNUM] = fip->frame + 4;
+// OBSOLETE   fsrp->regs[FP_REGNUM] = fip->frame;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE arc_push_dummy_frame (void)
+// OBSOLETE {
+// OBSOLETE   CORE_ADDR sp = read_register (SP_REGNUM);
+// OBSOLETE   int regnum;
+// OBSOLETE   char regbuf[MAX_REGISTER_RAW_SIZE];
+// OBSOLETE 
+// OBSOLETE   read_register_gen (PC_REGNUM, regbuf);
+// OBSOLETE   write_memory (sp + 4, regbuf, REGISTER_SIZE);
+// OBSOLETE   read_register_gen (FP_REGNUM, regbuf);
+// OBSOLETE   write_memory (sp, regbuf, REGISTER_SIZE);
+// OBSOLETE   write_register (FP_REGNUM, sp);
+// OBSOLETE   for (regnum = 0; regnum < NUM_REGS; regnum++)
+// OBSOLETE     {
+// OBSOLETE       read_register_gen (regnum, regbuf);
+// OBSOLETE       sp = push_bytes (sp, regbuf, REGISTER_RAW_SIZE (regnum));
+// OBSOLETE     }
+// OBSOLETE   sp += (2 * REGISTER_SIZE);
+// OBSOLETE   write_register (SP_REGNUM, sp);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE arc_pop_frame (void)
+// OBSOLETE {
+// OBSOLETE   struct frame_info *frame = get_current_frame ();
+// OBSOLETE   CORE_ADDR fp;
+// OBSOLETE   int regnum;
+// OBSOLETE   struct frame_saved_regs fsr;
+// OBSOLETE   char regbuf[MAX_REGISTER_RAW_SIZE];
+// OBSOLETE 
+// OBSOLETE   fp = FRAME_FP (frame);
+// OBSOLETE   get_frame_saved_regs (frame, &fsr);
+// OBSOLETE   for (regnum = 0; regnum < NUM_REGS; regnum++)
+// OBSOLETE     {
+// OBSOLETE       CORE_ADDR adr;
+// OBSOLETE       adr = fsr.regs[regnum];
+// OBSOLETE       if (adr)
+// OBSOLETE 	{
+// OBSOLETE 	  read_memory (adr, regbuf, REGISTER_RAW_SIZE (regnum));
+// OBSOLETE 	  write_register_bytes (REGISTER_BYTE (regnum), regbuf,
+// OBSOLETE 				REGISTER_RAW_SIZE (regnum));
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE   write_register (FP_REGNUM, read_memory_integer (fp, 4));
+// OBSOLETE   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
+// OBSOLETE   write_register (SP_REGNUM, fp + 8);
+// OBSOLETE   flush_cached_frames ();
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Simulate single-step.  */
+// OBSOLETE 
+// OBSOLETE typedef enum
+// OBSOLETE {
+// OBSOLETE   NORMAL4,			/* a normal 4 byte insn */
+// OBSOLETE   NORMAL8,			/* a normal 8 byte insn */
+// OBSOLETE   BRANCH4,			/* a 4 byte branch insn, including ones without delay slots */
+// OBSOLETE   BRANCH8,			/* an 8 byte branch insn, including ones with delay slots */
+// OBSOLETE }
+// OBSOLETE insn_type;
+// OBSOLETE 
+// OBSOLETE /* Return the type of INSN and store in TARGET the destination address of a
+// OBSOLETE    branch if this is one.  */
+// OBSOLETE /* ??? Need to verify all cases are properly handled.  */
+// OBSOLETE 
+// OBSOLETE static insn_type
+// OBSOLETE get_insn_type (unsigned long insn, CORE_ADDR pc, CORE_ADDR *target)
+// OBSOLETE {
+// OBSOLETE   unsigned long limm;
+// OBSOLETE 
+// OBSOLETE   switch (insn >> 27)
+// OBSOLETE     {
+// OBSOLETE     case 0:
+// OBSOLETE     case 1:
+// OBSOLETE     case 2:			/* load/store insns */
+// OBSOLETE       if (LIMM_P (X_A (insn))
+// OBSOLETE 	  || LIMM_P (X_B (insn))
+// OBSOLETE 	  || LIMM_P (X_C (insn)))
+// OBSOLETE 	return NORMAL8;
+// OBSOLETE       return NORMAL4;
+// OBSOLETE     case 4:
+// OBSOLETE     case 5:
+// OBSOLETE     case 6:			/* branch insns */
+// OBSOLETE       *target = pc + 4 + X_L (insn);
+// OBSOLETE       /* ??? It isn't clear that this is always the right answer.
+// OBSOLETE          The problem occurs when the next insn is an 8 byte insn.  If the
+// OBSOLETE          branch is conditional there's no worry as there shouldn't be an 8
+// OBSOLETE          byte insn following.  The programmer may be cheating if s/he knows
+// OBSOLETE          the branch will never be taken, but we don't deal with that.
+// OBSOLETE          Note that the programmer is also allowed to play games by putting
+// OBSOLETE          an insn with long immediate data in the delay slot and then duplicate
+// OBSOLETE          the long immediate data at the branch target.  Ugh!  */
+// OBSOLETE       if (X_N (insn) == 0)
+// OBSOLETE 	return BRANCH4;
+// OBSOLETE       return BRANCH8;
+// OBSOLETE     case 7:			/* jump insns */
+// OBSOLETE       if (LIMM_P (X_B (insn)))
+// OBSOLETE 	{
+// OBSOLETE 	  limm = read_memory_integer (pc + 4, 4);
+// OBSOLETE 	  *target = ARC_PC_TO_REAL_ADDRESS (limm);
+// OBSOLETE 	  return BRANCH8;
+// OBSOLETE 	}
+// OBSOLETE       if (SHIMM_P (X_B (insn)))
+// OBSOLETE 	*target = ARC_PC_TO_REAL_ADDRESS (X_D (insn));
+// OBSOLETE       else
+// OBSOLETE 	*target = ARC_PC_TO_REAL_ADDRESS (read_register (X_B (insn)));
+// OBSOLETE       if (X_Q (insn) == 0 && X_N (insn) == 0)
+// OBSOLETE 	return BRANCH4;
+// OBSOLETE       return BRANCH8;
+// OBSOLETE     default:			/* arithmetic insns, etc. */
+// OBSOLETE       if (LIMM_P (X_A (insn))
+// OBSOLETE 	  || LIMM_P (X_B (insn))
+// OBSOLETE 	  || LIMM_P (X_C (insn)))
+// OBSOLETE 	return NORMAL8;
+// OBSOLETE       return NORMAL4;
+// OBSOLETE     }
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* single_step() is called just before we want to resume the inferior, if we
+// OBSOLETE    want to single-step it but there is no hardware or kernel single-step
+// OBSOLETE    support.  We find all the possible targets of the coming instruction and
+// OBSOLETE    breakpoint them.
+// OBSOLETE 
+// OBSOLETE    single_step is also called just after the inferior stops.  If we had
+// OBSOLETE    set up a simulated single-step, we undo our damage.  */
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE arc_software_single_step (enum target_signal ignore,	/* sig but we don't need it */
+// OBSOLETE 			  int insert_breakpoints_p)
+// OBSOLETE {
+// OBSOLETE   static CORE_ADDR next_pc, target;
+// OBSOLETE   static int brktrg_p;
+// OBSOLETE   typedef char binsn_quantum[BREAKPOINT_MAX];
+// OBSOLETE   static binsn_quantum break_mem[2];
+// OBSOLETE 
+// OBSOLETE   if (insert_breakpoints_p)
+// OBSOLETE     {
+// OBSOLETE       insn_type type;
+// OBSOLETE       CORE_ADDR pc;
+// OBSOLETE       unsigned long insn;
+// OBSOLETE 
+// OBSOLETE       pc = read_register (PC_REGNUM);
+// OBSOLETE       insn = read_memory_integer (pc, 4);
+// OBSOLETE       type = get_insn_type (insn, pc, &target);
+// OBSOLETE 
+// OBSOLETE       /* Always set a breakpoint for the insn after the branch.  */
+// OBSOLETE       next_pc = pc + ((type == NORMAL8 || type == BRANCH8) ? 8 : 4);
+// OBSOLETE       target_insert_breakpoint (next_pc, break_mem[0]);
+// OBSOLETE 
+// OBSOLETE       brktrg_p = 0;
+// OBSOLETE 
+// OBSOLETE       if ((type == BRANCH4 || type == BRANCH8)
+// OBSOLETE       /* Watch out for branches to the following location.
+// OBSOLETE          We just stored a breakpoint there and another call to
+// OBSOLETE          target_insert_breakpoint will think the real insn is the
+// OBSOLETE          breakpoint we just stored there.  */
+// OBSOLETE 	  && target != next_pc)
+// OBSOLETE 	{
+// OBSOLETE 	  brktrg_p = 1;
+// OBSOLETE 	  target_insert_breakpoint (target, break_mem[1]);
+// OBSOLETE 	}
+// OBSOLETE 
+// OBSOLETE     }
+// OBSOLETE   else
+// OBSOLETE     {
+// OBSOLETE       /* Remove breakpoints.  */
+// OBSOLETE       target_remove_breakpoint (next_pc, break_mem[0]);
+// OBSOLETE 
+// OBSOLETE       if (brktrg_p)
+// OBSOLETE 	target_remove_breakpoint (target, break_mem[1]);
+// OBSOLETE 
+// OBSOLETE       /* Fix the pc.  */
+// OBSOLETE       stop_pc -= DECR_PC_AFTER_BREAK;
+// OBSOLETE       write_pc (stop_pc);
+// OBSOLETE     }
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Because of Multi-arch, GET_LONGJMP_TARGET is always defined.  So test
+// OBSOLETE    for a definition of JB_PC.  */
+// OBSOLETE #ifdef JB_PC
+// OBSOLETE /* Figure out where the longjmp will land.  Slurp the args out of the stack.
+// OBSOLETE    We expect the first arg to be a pointer to the jmp_buf structure from which
+// OBSOLETE    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
+// OBSOLETE    This routine returns true on success. */
+// OBSOLETE 
+// OBSOLETE int
+// OBSOLETE get_longjmp_target (CORE_ADDR *pc)
+// OBSOLETE {
+// OBSOLETE   char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
+// OBSOLETE   CORE_ADDR sp, jb_addr;
+// OBSOLETE 
+// OBSOLETE   sp = read_register (SP_REGNUM);
+// OBSOLETE 
+// OBSOLETE   if (target_read_memory (sp + SP_ARG0,		/* Offset of first arg on stack */
+// OBSOLETE 			  buf,
+// OBSOLETE 			  TARGET_PTR_BIT / TARGET_CHAR_BIT))
+// OBSOLETE     return 0;
+// OBSOLETE 
+// OBSOLETE   jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
+// OBSOLETE 
+// OBSOLETE   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
+// OBSOLETE 			  TARGET_PTR_BIT / TARGET_CHAR_BIT))
+// OBSOLETE     return 0;
+// OBSOLETE 
+// OBSOLETE   *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
+// OBSOLETE 
+// OBSOLETE   return 1;
+// OBSOLETE }
+// OBSOLETE #endif /* GET_LONGJMP_TARGET */
+// OBSOLETE 
+// OBSOLETE /* Disassemble one instruction.  */
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE arc_print_insn (bfd_vma vma, disassemble_info *info)
+// OBSOLETE {
+// OBSOLETE   static int current_mach;
+// OBSOLETE   static int current_endian;
+// OBSOLETE   static disassembler_ftype current_disasm;
+// OBSOLETE 
+// OBSOLETE   if (current_disasm == NULL
+// OBSOLETE       || arc_bfd_mach_type != current_mach
+// OBSOLETE       || TARGET_BYTE_ORDER != current_endian)
+// OBSOLETE     {
+// OBSOLETE       current_mach = arc_bfd_mach_type;
+// OBSOLETE       current_endian = TARGET_BYTE_ORDER;
+// OBSOLETE       current_disasm = arc_get_disassembler (NULL);
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   return (*current_disasm) (vma, info);
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Command to set cpu type.  */
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE arc_set_cpu_type_command (char *args, int from_tty)
+// OBSOLETE {
+// OBSOLETE   int i;
+// OBSOLETE 
+// OBSOLETE   if (tmp_arc_cpu_type == NULL || *tmp_arc_cpu_type == '\0')
+// OBSOLETE     {
+// OBSOLETE       printf_unfiltered ("The known ARC cpu types are as follows:\n");
+// OBSOLETE       for (i = 0; arc_cpu_type_table[i].name != NULL; ++i)
+// OBSOLETE 	printf_unfiltered ("%s\n", arc_cpu_type_table[i].name);
+// OBSOLETE 
+// OBSOLETE       /* Restore the value.  */
+// OBSOLETE       tmp_arc_cpu_type = xstrdup (arc_cpu_type);
+// OBSOLETE 
+// OBSOLETE       return;
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   if (!arc_set_cpu_type (tmp_arc_cpu_type))
+// OBSOLETE     {
+// OBSOLETE       error ("Unknown cpu type `%s'.", tmp_arc_cpu_type);
+// OBSOLETE       /* Restore its value.  */
+// OBSOLETE       tmp_arc_cpu_type = xstrdup (arc_cpu_type);
+// OBSOLETE     }
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE static void
+// OBSOLETE arc_show_cpu_type_command (char *args, int from_tty)
+// OBSOLETE {
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Modify the actual cpu type.
+// OBSOLETE    Result is a boolean indicating success.  */
+// OBSOLETE 
+// OBSOLETE static int
+// OBSOLETE arc_set_cpu_type (char *str)
+// OBSOLETE {
+// OBSOLETE   int i, j;
+// OBSOLETE 
+// OBSOLETE   if (str == NULL)
+// OBSOLETE     return 0;
+// OBSOLETE 
+// OBSOLETE   for (i = 0; arc_cpu_type_table[i].name != NULL; ++i)
+// OBSOLETE     {
+// OBSOLETE       if (strcasecmp (str, arc_cpu_type_table[i].name) == 0)
+// OBSOLETE 	{
+// OBSOLETE 	  arc_cpu_type = str;
+// OBSOLETE 	  arc_bfd_mach_type = arc_cpu_type_table[i].value;
+// OBSOLETE 	  return 1;
+// OBSOLETE 	}
+// OBSOLETE     }
+// OBSOLETE 
+// OBSOLETE   return 0;
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE void
+// OBSOLETE _initialize_arc_tdep (void)
+// OBSOLETE {
+// OBSOLETE   struct cmd_list_element *c;
+// OBSOLETE 
+// OBSOLETE   c = add_set_cmd ("cpu", class_support, var_string_noescape,
+// OBSOLETE 		   (char *) &tmp_arc_cpu_type,
+// OBSOLETE 		   "Set the type of ARC cpu in use.\n\
+// OBSOLETE This command has two purposes.  In a multi-cpu system it lets one\n\
+// OBSOLETE change the cpu being debugged.  It also gives one access to\n\
+// OBSOLETE cpu-type-specific registers and recognize cpu-type-specific instructions.\
+// OBSOLETE ",
+// OBSOLETE 		   &setlist);
+// OBSOLETE   set_cmd_cfunc (c, arc_set_cpu_type_command);
+// OBSOLETE   c = add_show_from_set (c, &showlist);
+// OBSOLETE   set_cmd_cfunc (c, arc_show_cpu_type_command);
+// OBSOLETE 
+// OBSOLETE   /* We have to use xstrdup() here because the `set' command frees it
+// OBSOLETE      before setting a new value.  */
+// OBSOLETE   tmp_arc_cpu_type = xstrdup (DEFAULT_ARC_CPU_TYPE);
+// OBSOLETE   arc_set_cpu_type (tmp_arc_cpu_type);
+// OBSOLETE 
+// OBSOLETE   c = add_set_cmd ("displaypipeline", class_support, var_zinteger,
+// OBSOLETE 		   (char *) &display_pipeline_p,
+// OBSOLETE 		   "Set pipeline display (simulator only).\n\
+// OBSOLETE When enabled, the state of the pipeline after each cycle is displayed.",
+// OBSOLETE 		   &setlist);
+// OBSOLETE   c = add_show_from_set (c, &showlist);
+// OBSOLETE 
+// OBSOLETE   c = add_set_cmd ("debugpipeline", class_support, var_zinteger,
+// OBSOLETE 		   (char *) &debug_pipeline_p,
+// OBSOLETE 		   "Set pipeline debug display (simulator only).\n\
+// OBSOLETE When enabled, debugging information about the pipeline is displayed.",
+// OBSOLETE 		   &setlist);
+// OBSOLETE   c = add_show_from_set (c, &showlist);
+// OBSOLETE 
+// OBSOLETE   c = add_set_cmd ("cputimer", class_support, var_zinteger,
+// OBSOLETE 		   (char *) &cpu_timer,
+// OBSOLETE 		   "Set maximum cycle count (simulator only).\n\
+// OBSOLETE Control will return to gdb if the timer expires.\n\
+// OBSOLETE A negative value disables the timer.",
+// OBSOLETE 		   &setlist);
+// OBSOLETE   c = add_show_from_set (c, &showlist);
+// OBSOLETE 
+// OBSOLETE   tm_print_insn = arc_print_insn;
+// OBSOLETE }
diff --git a/gdb/config/arc/arc.mt b/gdb/config/arc/arc.mt
index 8ee8c3d..3ed7410 100644
--- a/gdb/config/arc/arc.mt
+++ b/gdb/config/arc/arc.mt
@@ -1,3 +1,3 @@
-# Target: ARC processor
-TDEPFILES = arc-tdep.o
-TM_FILE = tm-arc.h
+# OBSOLETE # Target: ARC processor
+# OBSOLETE TDEPFILES = arc-tdep.o
+# OBSOLETE TM_FILE = tm-arc.h
diff --git a/gdb/config/arc/tm-arc.h b/gdb/config/arc/tm-arc.h
index af183b6..1c7c74f 100644
--- a/gdb/config/arc/tm-arc.h
+++ b/gdb/config/arc/tm-arc.h
@@ -1,336 +1,336 @@
-/* Parameters for target machine ARC, for GDB, the GNU debugger.
-   Copyright 1995, 1996, 1998, 1999, 2000 Free Software Foundation, Inc.
-   Contributed by Cygnus Support.
-
-   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.  */
-
-#include "regcache.h"
-
-/* Used by arc-tdep.c to set the default cpu type.  */
-#define DEFAULT_ARC_CPU_TYPE "base"
-
-/* Offset from address of function to start of its code.
-   Zero on most machines.  */
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
-   to reach some "real" code.  */
-
-#define SKIP_PROLOGUE(pc) (arc_skip_prologue (pc, 0))
-extern CORE_ADDR arc_skip_prologue (CORE_ADDR, int);
-
-#define PROLOGUE_FRAMELESS_P(pc) arc_prologue_frameless_p(pc)
-extern int arc_prologue_frameless_p (CORE_ADDR);
-
-/* Sequence of bytes for breakpoint instruction.
-   ??? The current value is "sr -1,[-1]" and is for the simulator only.
-   The simulator watches for this and does the right thing.
-   The hardware version will have to associate with each breakpoint
-   the sequence "flag 1; nop; nop; nop".  IE: The breakpoint insn will not
-   be a fixed set of bits but instead will be a branch to a semi-random
-   address.  Presumably this will be cleaned up for "second silicon".  */
-#define BIG_BREAKPOINT { 0x12, 0x1f, 0xff, 0xff }
-#define LITTLE_BREAKPOINT { 0xff, 0xff, 0x1f, 0x12 }
-
-/* Given the exposed pipeline, there isn't any one correct value.
-   However, this value must be 4.  GDB can't handle any other value (other than
-   zero).  See for example infrun.c:
-   "prev_pc != stop_pc - DECR_PC_AFTER_BREAK"  */
-/* FIXME */
-#define DECR_PC_AFTER_BREAK 8
-
-/* We don't have a reliable single step facility.
-   ??? We do have a cycle single step facility, but that won't work.  */
-#define SOFTWARE_SINGLE_STEP_P() 1
-extern void arc_software_single_step (enum target_signal, int);
-#define SOFTWARE_SINGLE_STEP(sig,bp_p) arc_software_single_step (sig, bp_p)
-
-/* FIXME: Need to set STEP_SKIPS_DELAY.  */
-
-/* Given a pc value as defined by the hardware, return the real address.
-   Remember that on the ARC blink contains that status register which
-   includes PC + flags (so we have to mask out the flags).  */
-#define ARC_PC_TO_REAL_ADDRESS(pc) (((pc) & 0xffffff) << 2)
-
-/* Immediately after a function call, return the saved pc.
-   Can't always go through the frames for this because on some machines
-   the new frame is not set up until the new function
-   executes some instructions.  */
-
-#define SAVED_PC_AFTER_CALL(frame) \
-  (ARC_PC_TO_REAL_ADDRESS (read_register (BLINK_REGNUM)))
-
-/* Stack grows upward */
-
-#define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
-
-/* Say how long (ordinary) registers are.  This is a piece of bogosity
-   used in push_word and a few other places; REGISTER_RAW_SIZE is the
-   real way to know how big a register is.  */
-#define REGISTER_SIZE 4
-
-/* Number of machine registers */
-#define NUM_REGS 92
-
-/* Initializer for an array of names of registers.
-   There should be NUM_REGS strings in this initializer.  */
-
-#define REGISTER_NAMES \
-{ \
-    /*  0 */ "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7", \
-    /*  8 */ "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15", \
-    /* 16 */ "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", \
-    /* 24 */ "r24", "r25", "r26", "fp", "sp", "ilink1", "ilink2", "blink", \
-    /* 32 */ "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39", \
-    /* 40 */ "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47", \
-    /* 48 */ "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55", \
-    /* 56 */ "r56", "mlo", "mmid", "mhi", "lp_count", \
-    /* 61 */ "status", "sema", "lp_start", "lp_end", "identity", "debug", \
-    /* 67 */ "aux10", "aux11", "aux12", "aux13", "aux14", \
-    /* 72 */ "aux15", "aux16", "aux17", "aux18", "aux19", \
-    /* 77 */ "aux1a", "aux1b", "aux1c", "aux1d", "aux1e", \
-    /* 82 */ "aux1f", "aux20", "aux21", "aux22", \
-    /* 86 */ "aux30", "aux31", "aux32", "aux33", "aux40", \
-    /* 91 */ "pc" \
-}
-
-/* Register numbers of various important registers (used to index
-   into arrays of register names and register values).  */
-
-#define R0_REGNUM   0		/* First local register           */
-#define R59_REGNUM 59		/* Last local register            */
-#define FP_REGNUM  27		/* Contains address of executing stack frame */
-#define SP_REGNUM  28		/* stack pointer */
-#define BLINK_REGNUM 31		/* link register */
-#define	STA_REGNUM 61		/* processor status word */
-#define PC_REGNUM  91		/* instruction pointer */
-#define AUX_BEG_REGNUM  61	/* aux reg begins */
-#define AUX_END_REGNUM  90	/* aux reg ends, pc not real aux reg */
-
-/* Fake registers used to mark immediate data.  */
-#define SHIMM_FLAG_REGNUM 61
-#define LIMM_REGNUM 62
-#define SHIMM_REGNUM 63
-
-#define AUX_REG_MAP \
-{ \
-   {  0,  1,  2,  3,  4,  5, \
-     16, -1, -1, -1, -1, \
-     -1, -1, -1, -1, -1, \
-     -1, -1, -1, -1, 30, \
-     -1, 32, 33, -1, \
-      48, 49, 50, 51, 64, \
-      0 \
-    }, \
-   {  0,  1,  2,  3,  4,  5, \
-     16, -1, -1, -1, -1, \
-     -1, -1, -1, -1, -1, \
-     -1, -1, -1, -1, 30, \
-     31, 32, 33, -1, \
-     -1, -1, -1, -1, -1, \
-      0 \
-    }, \
-   {  0,  1,  2,  3,  4,  5, \
-      16, 17, 18, 19, 20, \
-      21, 22, 23, 24, 25, \
-      26, 27, 28, 29, 30, \
-      31, 32, 33, 34, \
-     -1, -1, -1, -1, -1, \
-      0 \
-    } \
-}
-
-#define PFP_REGNUM R0_REGNUM	/* Previous frame pointer */
-
-/* Total amount of space needed to store our copies of the machine's
-   register state, the array `registers'.  */
-#define REGISTER_BYTES (NUM_REGS * 4)
-
-/* Index within `registers' of the first byte of the space for register N.  */
-#define REGISTER_BYTE(N) (4*(N))
-
-/* Number of bytes of storage in the actual machine representation
-   for register N. */
-#define REGISTER_RAW_SIZE(N) 4
-
-/* Number of bytes of storage in the program's representation for register N. */
-#define REGISTER_VIRTUAL_SIZE(N) 4
-
-/* Largest value REGISTER_RAW_SIZE can have.  */
-#define MAX_REGISTER_RAW_SIZE 4
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
-#define MAX_REGISTER_VIRTUAL_SIZE 4
-
-/* Return the GDB type object for the "standard" data type
-   of data in register N.  */
-#define REGISTER_VIRTUAL_TYPE(N) (builtin_type_int)
-
-
-/* Macros for understanding function return values... */
-
-/* Does the specified function use the "struct returning" convention
-   or the "value returning" convention?  The "value returning" convention
-   almost invariably returns the entire value in registers.  The
-   "struct returning" convention often returns the entire value in
-   memory, and passes a pointer (out of or into the function) saying
-   where the value (is or should go).
-
-   Since this sometimes depends on whether it was compiled with GCC,
-   this is also an argument.  This is used in call_function to build a
-   stack, and in value_being_returned to print return values.
-
-   On arc, a structure is always retunred with pointer in r0. */
-
-#define USE_STRUCT_CONVENTION(gcc_p, type) 1
-
-/* Extract from an array REGBUF containing the (raw) register state
-   a function return value of type TYPE, and copy that, in virtual format,
-   into VALBUF.  This is only called if USE_STRUCT_CONVENTION for this
-   type is 0.
- */
-#define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
-	memcpy(VALBUF, REGBUF+REGISTER_BYTE(R0_REGNUM), TYPE_LENGTH (TYPE))
-
-/* If USE_STRUCT_CONVENTION produces a 1, 
-   extract from an array REGBUF containing the (raw) register state
-   the address in which a function should return its structure value,
-   as a CORE_ADDR (or an expression that can be used as one). */
-#define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
-   (error("Don't know where large structure is returned on arc"), 0)
-
-/* Write into appropriate registers a function return value
-   of type TYPE, given in virtual format, for "value returning" functions.
-   For 'return' command:  not (yet) implemented for arc.  */
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
-    error ("Returning values from functions is not implemented in arc gdb")
-
-/* Store the address of the place in which to copy the structure the
-   subroutine will return.  This is called from call_function. */
-#define STORE_STRUCT_RETURN(ADDR, SP) \
-    error ("Returning values from functions is not implemented in arc gdb")
-
-
-/* Describe the pointer in each stack frame to the previous stack frame
-   (its caller).  */
-
-/* We cache information about saved registers in the frame structure,
-   to save us from having to re-scan function prologues every time
-   a register in a non-current frame is accessed.  */
-
-#define EXTRA_FRAME_INFO \
-	struct frame_saved_regs *fsr; \
-	CORE_ADDR arg_pointer;
-
-/* Zero the frame_saved_regs pointer when the frame is initialized,
-   so that FRAME_FIND_SAVED_REGS () will know to allocate and
-   initialize a frame_saved_regs struct the first time it is called.
-   Set the arg_pointer to -1, which is not valid; 0 and other values
-   indicate real, cached values.  */
-
-#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
-	((fi)->fsr = 0, (fi)->arg_pointer = -1)
-
-/* FRAME_CHAIN takes a frame's nominal address
-   and produces the frame's chain-pointer.
-   However, if FRAME_CHAIN_VALID returns zero,
-   it means the given frame is the outermost one and has no caller.  */
-/* On the arc, we get the chain pointer by reading the PFP saved
-   on the stack. */
-/* The PFP and RPC is in fp and fp+4.  */
-
-#define FRAME_CHAIN(thisframe) \
-  (read_memory_integer (FRAME_FP (thisframe), 4))
-
-/* FRAME_CHAIN_VALID returns zero if the given frame is the outermost one
-   and has no caller.  */
-#define FRAME_CHAIN_VALID(chain, thisframe) nonnull_frame_chain_valid (chain, thisframe)
-
-/* An expression that tells us whether the function invocation represented
-   by FI does not have a frame on the stack associated with it. */
-
-#define FRAMELESS_FUNCTION_INVOCATION(FI) \
-     (((FI)->signal_handler_caller) ? 0 : frameless_look_for_prologue (FI))
-
-/* Where is the PC for a specific frame.
-   A leaf function may never save blink, so we have to check for that here.  */
-
-#define FRAME_SAVED_PC(frame) (arc_frame_saved_pc (frame))
-struct frame_info;		/* in case frame.h not included yet */
-CORE_ADDR arc_frame_saved_pc (struct frame_info *);
-
-/* If the argument is on the stack, it will be here.
-   We cache this value in the frame info if we've already looked it up.  */
-/* ??? Is the arg_pointer check necessary?  */
-
-#define FRAME_ARGS_ADDRESS(fi) \
-  (((fi)->arg_pointer != -1) ? (fi)->arg_pointer : (fi)->frame)
-
-/* This is the same except it should return 0 when
-   it does not really know where the args are, rather than guessing.
-   This value is not cached since it is only used infrequently.  */
-
-#define FRAME_LOCALS_ADDRESS(fi)	((fi)->frame)
-
-/* Set NUMARGS to the number of args passed to a frame.
-   Can return -1, meaning no way to tell.  */
-
-#define FRAME_NUM_ARGS(fi)	(-1)
-
-/* Return number of bytes at start of arglist that are not really args.  */
-
-#define FRAME_ARGS_SKIP 0
-
-/* Produce the positions of the saved registers in a stack frame.  */
-
-#define FRAME_FIND_SAVED_REGS(frame_info_addr, sr) \
-	frame_find_saved_regs (frame_info_addr, &sr)
-extern void frame_find_saved_regs ();	/* See arc-tdep.c */
-
-
-/* Things needed for making calls to functions in the inferior process */
-void arc_push_dummy_frame (void);
-#define PUSH_DUMMY_FRAME \
-	arc_push_dummy_frame ()
-
-/* Discard from the stack the innermost frame, restoring all registers.  */
-void arc_pop_frame (void);
-#define POP_FRAME \
-	arc_pop_frame ()
-
-/* This sequence of words is the instructions  bl xxxx, flag 1 */
-#define CALL_DUMMY { 0x28000000, 0x1fbe8001 }
-#define CALL_DUMMY_LENGTH 8
-
-/* Start execution at beginning of dummy */
-#define CALL_DUMMY_START_OFFSET 0
-
-/* Insert the specified number of args and function address
-   into a call sequence of the above form stored at 'dummyname'. */
-#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
-{ \
-        int from, to, delta, loc; \
-        loc = (int)(read_register (SP_REGNUM) - CALL_DUMMY_LENGTH); \
-        from = loc + 4; \
-        to = (int)(fun); \
-        delta = (to - from) >> 2; \
-        *((char *)(dummyname) + 1) = (delta & 0x1); \
-        *((char *)(dummyname) + 2) = ((delta >> 1) & 0xff); \
-        *((char *)(dummyname) + 3) = ((delta >> 9) & 0xff); \
-        *((char *)(dummyname) + 4) = ((delta >> 17) & 0x7); \
-}
+// OBSOLETE /* Parameters for target machine ARC, for GDB, the GNU debugger.
+// OBSOLETE    Copyright 1995, 1996, 1998, 1999, 2000 Free Software Foundation, Inc.
+// OBSOLETE    Contributed by Cygnus Support.
+// 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 #include "regcache.h"
+// OBSOLETE 
+// OBSOLETE /* Used by arc-tdep.c to set the default cpu type.  */
+// OBSOLETE #define DEFAULT_ARC_CPU_TYPE "base"
+// OBSOLETE 
+// OBSOLETE /* Offset from address of function to start of its code.
+// OBSOLETE    Zero on most machines.  */
+// OBSOLETE #define FUNCTION_START_OFFSET 0
+// OBSOLETE 
+// OBSOLETE /* Advance PC across any function entry prologue instructions
+// OBSOLETE    to reach some "real" code.  */
+// OBSOLETE 
+// OBSOLETE #define SKIP_PROLOGUE(pc) (arc_skip_prologue (pc, 0))
+// OBSOLETE extern CORE_ADDR arc_skip_prologue (CORE_ADDR, int);
+// OBSOLETE 
+// OBSOLETE #define PROLOGUE_FRAMELESS_P(pc) arc_prologue_frameless_p(pc)
+// OBSOLETE extern int arc_prologue_frameless_p (CORE_ADDR);
+// OBSOLETE 
+// OBSOLETE /* Sequence of bytes for breakpoint instruction.
+// OBSOLETE    ??? The current value is "sr -1,[-1]" and is for the simulator only.
+// OBSOLETE    The simulator watches for this and does the right thing.
+// OBSOLETE    The hardware version will have to associate with each breakpoint
+// OBSOLETE    the sequence "flag 1; nop; nop; nop".  IE: The breakpoint insn will not
+// OBSOLETE    be a fixed set of bits but instead will be a branch to a semi-random
+// OBSOLETE    address.  Presumably this will be cleaned up for "second silicon".  */
+// OBSOLETE #define BIG_BREAKPOINT { 0x12, 0x1f, 0xff, 0xff }
+// OBSOLETE #define LITTLE_BREAKPOINT { 0xff, 0xff, 0x1f, 0x12 }
+// OBSOLETE 
+// OBSOLETE /* Given the exposed pipeline, there isn't any one correct value.
+// OBSOLETE    However, this value must be 4.  GDB can't handle any other value (other than
+// OBSOLETE    zero).  See for example infrun.c:
+// OBSOLETE    "prev_pc != stop_pc - DECR_PC_AFTER_BREAK"  */
+// OBSOLETE /* FIXME */
+// OBSOLETE #define DECR_PC_AFTER_BREAK 8
+// OBSOLETE 
+// OBSOLETE /* We don't have a reliable single step facility.
+// OBSOLETE    ??? We do have a cycle single step facility, but that won't work.  */
+// OBSOLETE #define SOFTWARE_SINGLE_STEP_P() 1
+// OBSOLETE extern void arc_software_single_step (enum target_signal, int);
+// OBSOLETE #define SOFTWARE_SINGLE_STEP(sig,bp_p) arc_software_single_step (sig, bp_p)
+// OBSOLETE 
+// OBSOLETE /* FIXME: Need to set STEP_SKIPS_DELAY.  */
+// OBSOLETE 
+// OBSOLETE /* Given a pc value as defined by the hardware, return the real address.
+// OBSOLETE    Remember that on the ARC blink contains that status register which
+// OBSOLETE    includes PC + flags (so we have to mask out the flags).  */
+// OBSOLETE #define ARC_PC_TO_REAL_ADDRESS(pc) (((pc) & 0xffffff) << 2)
+// OBSOLETE 
+// OBSOLETE /* Immediately after a function call, return the saved pc.
+// OBSOLETE    Can't always go through the frames for this because on some machines
+// OBSOLETE    the new frame is not set up until the new function
+// OBSOLETE    executes some instructions.  */
+// OBSOLETE 
+// OBSOLETE #define SAVED_PC_AFTER_CALL(frame) \
+// OBSOLETE   (ARC_PC_TO_REAL_ADDRESS (read_register (BLINK_REGNUM)))
+// OBSOLETE 
+// OBSOLETE /* Stack grows upward */
+// OBSOLETE 
+// OBSOLETE #define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
+// OBSOLETE 
+// OBSOLETE /* Say how long (ordinary) registers are.  This is a piece of bogosity
+// OBSOLETE    used in push_word and a few other places; REGISTER_RAW_SIZE is the
+// OBSOLETE    real way to know how big a register is.  */
+// OBSOLETE #define REGISTER_SIZE 4
+// OBSOLETE 
+// OBSOLETE /* Number of machine registers */
+// OBSOLETE #define NUM_REGS 92
+// OBSOLETE 
+// OBSOLETE /* Initializer for an array of names of registers.
+// OBSOLETE    There should be NUM_REGS strings in this initializer.  */
+// OBSOLETE 
+// OBSOLETE #define REGISTER_NAMES \
+// OBSOLETE { \
+// OBSOLETE     /*  0 */ "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7", \
+// OBSOLETE     /*  8 */ "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15", \
+// OBSOLETE     /* 16 */ "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", \
+// OBSOLETE     /* 24 */ "r24", "r25", "r26", "fp", "sp", "ilink1", "ilink2", "blink", \
+// OBSOLETE     /* 32 */ "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39", \
+// OBSOLETE     /* 40 */ "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47", \
+// OBSOLETE     /* 48 */ "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55", \
+// OBSOLETE     /* 56 */ "r56", "mlo", "mmid", "mhi", "lp_count", \
+// OBSOLETE     /* 61 */ "status", "sema", "lp_start", "lp_end", "identity", "debug", \
+// OBSOLETE     /* 67 */ "aux10", "aux11", "aux12", "aux13", "aux14", \
+// OBSOLETE     /* 72 */ "aux15", "aux16", "aux17", "aux18", "aux19", \
+// OBSOLETE     /* 77 */ "aux1a", "aux1b", "aux1c", "aux1d", "aux1e", \
+// OBSOLETE     /* 82 */ "aux1f", "aux20", "aux21", "aux22", \
+// OBSOLETE     /* 86 */ "aux30", "aux31", "aux32", "aux33", "aux40", \
+// OBSOLETE     /* 91 */ "pc" \
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE /* Register numbers of various important registers (used to index
+// OBSOLETE    into arrays of register names and register values).  */
+// OBSOLETE 
+// OBSOLETE #define R0_REGNUM   0		/* First local register           */
+// OBSOLETE #define R59_REGNUM 59		/* Last local register            */
+// OBSOLETE #define FP_REGNUM  27		/* Contains address of executing stack frame */
+// OBSOLETE #define SP_REGNUM  28		/* stack pointer */
+// OBSOLETE #define BLINK_REGNUM 31		/* link register */
+// OBSOLETE #define	STA_REGNUM 61		/* processor status word */
+// OBSOLETE #define PC_REGNUM  91		/* instruction pointer */
+// OBSOLETE #define AUX_BEG_REGNUM  61	/* aux reg begins */
+// OBSOLETE #define AUX_END_REGNUM  90	/* aux reg ends, pc not real aux reg */
+// OBSOLETE 
+// OBSOLETE /* Fake registers used to mark immediate data.  */
+// OBSOLETE #define SHIMM_FLAG_REGNUM 61
+// OBSOLETE #define LIMM_REGNUM 62
+// OBSOLETE #define SHIMM_REGNUM 63
+// OBSOLETE 
+// OBSOLETE #define AUX_REG_MAP \
+// OBSOLETE { \
+// OBSOLETE    {  0,  1,  2,  3,  4,  5, \
+// OBSOLETE      16, -1, -1, -1, -1, \
+// OBSOLETE      -1, -1, -1, -1, -1, \
+// OBSOLETE      -1, -1, -1, -1, 30, \
+// OBSOLETE      -1, 32, 33, -1, \
+// OBSOLETE       48, 49, 50, 51, 64, \
+// OBSOLETE       0 \
+// OBSOLETE     }, \
+// OBSOLETE    {  0,  1,  2,  3,  4,  5, \
+// OBSOLETE      16, -1, -1, -1, -1, \
+// OBSOLETE      -1, -1, -1, -1, -1, \
+// OBSOLETE      -1, -1, -1, -1, 30, \
+// OBSOLETE      31, 32, 33, -1, \
+// OBSOLETE      -1, -1, -1, -1, -1, \
+// OBSOLETE       0 \
+// OBSOLETE     }, \
+// OBSOLETE    {  0,  1,  2,  3,  4,  5, \
+// OBSOLETE       16, 17, 18, 19, 20, \
+// OBSOLETE       21, 22, 23, 24, 25, \
+// OBSOLETE       26, 27, 28, 29, 30, \
+// OBSOLETE       31, 32, 33, 34, \
+// OBSOLETE      -1, -1, -1, -1, -1, \
+// OBSOLETE       0 \
+// OBSOLETE     } \
+// OBSOLETE }
+// OBSOLETE 
+// OBSOLETE #define PFP_REGNUM R0_REGNUM	/* Previous frame pointer */
+// OBSOLETE 
+// OBSOLETE /* Total amount of space needed to store our copies of the machine's
+// OBSOLETE    register state, the array `registers'.  */
+// OBSOLETE #define REGISTER_BYTES (NUM_REGS * 4)
+// OBSOLETE 
+// OBSOLETE /* Index within `registers' of the first byte of the space for register N.  */
+// OBSOLETE #define REGISTER_BYTE(N) (4*(N))
+// OBSOLETE 
+// OBSOLETE /* Number of bytes of storage in the actual machine representation
+// OBSOLETE    for register N. */
+// OBSOLETE #define REGISTER_RAW_SIZE(N) 4
+// OBSOLETE 
+// OBSOLETE /* Number of bytes of storage in the program's representation for register N. */
+// OBSOLETE #define REGISTER_VIRTUAL_SIZE(N) 4
+// OBSOLETE 
+// OBSOLETE /* Largest value REGISTER_RAW_SIZE can have.  */
+// OBSOLETE #define MAX_REGISTER_RAW_SIZE 4
+// OBSOLETE 
+// OBSOLETE /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+// OBSOLETE #define MAX_REGISTER_VIRTUAL_SIZE 4
+// OBSOLETE 
+// OBSOLETE /* Return the GDB type object for the "standard" data type
+// OBSOLETE    of data in register N.  */
+// OBSOLETE #define REGISTER_VIRTUAL_TYPE(N) (builtin_type_int)
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE /* Macros for understanding function return values... */
+// OBSOLETE 
+// OBSOLETE /* Does the specified function use the "struct returning" convention
+// OBSOLETE    or the "value returning" convention?  The "value returning" convention
+// OBSOLETE    almost invariably returns the entire value in registers.  The
+// OBSOLETE    "struct returning" convention often returns the entire value in
+// OBSOLETE    memory, and passes a pointer (out of or into the function) saying
+// OBSOLETE    where the value (is or should go).
+// OBSOLETE 
+// OBSOLETE    Since this sometimes depends on whether it was compiled with GCC,
+// OBSOLETE    this is also an argument.  This is used in call_function to build a
+// OBSOLETE    stack, and in value_being_returned to print return values.
+// OBSOLETE 
+// OBSOLETE    On arc, a structure is always retunred with pointer in r0. */
+// OBSOLETE 
+// OBSOLETE #define USE_STRUCT_CONVENTION(gcc_p, type) 1
+// OBSOLETE 
+// OBSOLETE /* Extract from an array REGBUF containing the (raw) register state
+// OBSOLETE    a function return value of type TYPE, and copy that, in virtual format,
+// OBSOLETE    into VALBUF.  This is only called if USE_STRUCT_CONVENTION for this
+// OBSOLETE    type is 0.
+// OBSOLETE  */
+// OBSOLETE #define DEPRECATED_EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+// OBSOLETE 	memcpy(VALBUF, REGBUF+REGISTER_BYTE(R0_REGNUM), TYPE_LENGTH (TYPE))
+// OBSOLETE 
+// OBSOLETE /* If USE_STRUCT_CONVENTION produces a 1, 
+// OBSOLETE    extract from an array REGBUF containing the (raw) register state
+// OBSOLETE    the address in which a function should return its structure value,
+// OBSOLETE    as a CORE_ADDR (or an expression that can be used as one). */
+// OBSOLETE #define DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
+// OBSOLETE    (error("Don't know where large structure is returned on arc"), 0)
+// OBSOLETE 
+// OBSOLETE /* Write into appropriate registers a function return value
+// OBSOLETE    of type TYPE, given in virtual format, for "value returning" functions.
+// OBSOLETE    For 'return' command:  not (yet) implemented for arc.  */
+// OBSOLETE #define STORE_RETURN_VALUE(TYPE,VALBUF) \
+// OBSOLETE     error ("Returning values from functions is not implemented in arc gdb")
+// OBSOLETE 
+// OBSOLETE /* Store the address of the place in which to copy the structure the
+// OBSOLETE    subroutine will return.  This is called from call_function. */
+// OBSOLETE #define STORE_STRUCT_RETURN(ADDR, SP) \
+// OBSOLETE     error ("Returning values from functions is not implemented in arc gdb")
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE /* Describe the pointer in each stack frame to the previous stack frame
+// OBSOLETE    (its caller).  */
+// OBSOLETE 
+// OBSOLETE /* We cache information about saved registers in the frame structure,
+// OBSOLETE    to save us from having to re-scan function prologues every time
+// OBSOLETE    a register in a non-current frame is accessed.  */
+// OBSOLETE 
+// OBSOLETE #define EXTRA_FRAME_INFO \
+// OBSOLETE 	struct frame_saved_regs *fsr; \
+// OBSOLETE 	CORE_ADDR arg_pointer;
+// OBSOLETE 
+// OBSOLETE /* Zero the frame_saved_regs pointer when the frame is initialized,
+// OBSOLETE    so that FRAME_FIND_SAVED_REGS () will know to allocate and
+// OBSOLETE    initialize a frame_saved_regs struct the first time it is called.
+// OBSOLETE    Set the arg_pointer to -1, which is not valid; 0 and other values
+// OBSOLETE    indicate real, cached values.  */
+// OBSOLETE 
+// OBSOLETE #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
+// OBSOLETE 	((fi)->fsr = 0, (fi)->arg_pointer = -1)
+// OBSOLETE 
+// OBSOLETE /* FRAME_CHAIN takes a frame's nominal address
+// OBSOLETE    and produces the frame's chain-pointer.
+// OBSOLETE    However, if FRAME_CHAIN_VALID returns zero,
+// OBSOLETE    it means the given frame is the outermost one and has no caller.  */
+// OBSOLETE /* On the arc, we get the chain pointer by reading the PFP saved
+// OBSOLETE    on the stack. */
+// OBSOLETE /* The PFP and RPC is in fp and fp+4.  */
+// OBSOLETE 
+// OBSOLETE #define FRAME_CHAIN(thisframe) \
+// OBSOLETE   (read_memory_integer (FRAME_FP (thisframe), 4))
+// OBSOLETE 
+// OBSOLETE /* FRAME_CHAIN_VALID returns zero if the given frame is the outermost one
+// OBSOLETE    and has no caller.  */
+// OBSOLETE #define FRAME_CHAIN_VALID(chain, thisframe) nonnull_frame_chain_valid (chain, thisframe)
+// OBSOLETE 
+// OBSOLETE /* An expression that tells us whether the function invocation represented
+// OBSOLETE    by FI does not have a frame on the stack associated with it. */
+// OBSOLETE 
+// OBSOLETE #define FRAMELESS_FUNCTION_INVOCATION(FI) \
+// OBSOLETE      (((FI)->signal_handler_caller) ? 0 : frameless_look_for_prologue (FI))
+// OBSOLETE 
+// OBSOLETE /* Where is the PC for a specific frame.
+// OBSOLETE    A leaf function may never save blink, so we have to check for that here.  */
+// OBSOLETE 
+// OBSOLETE #define FRAME_SAVED_PC(frame) (arc_frame_saved_pc (frame))
+// OBSOLETE struct frame_info;		/* in case frame.h not included yet */
+// OBSOLETE CORE_ADDR arc_frame_saved_pc (struct frame_info *);
+// OBSOLETE 
+// OBSOLETE /* If the argument is on the stack, it will be here.
+// OBSOLETE    We cache this value in the frame info if we've already looked it up.  */
+// OBSOLETE /* ??? Is the arg_pointer check necessary?  */
+// OBSOLETE 
+// OBSOLETE #define FRAME_ARGS_ADDRESS(fi) \
+// OBSOLETE   (((fi)->arg_pointer != -1) ? (fi)->arg_pointer : (fi)->frame)
+// OBSOLETE 
+// OBSOLETE /* This is the same except it should return 0 when
+// OBSOLETE    it does not really know where the args are, rather than guessing.
+// OBSOLETE    This value is not cached since it is only used infrequently.  */
+// OBSOLETE 
+// OBSOLETE #define FRAME_LOCALS_ADDRESS(fi)	((fi)->frame)
+// OBSOLETE 
+// OBSOLETE /* Set NUMARGS to the number of args passed to a frame.
+// OBSOLETE    Can return -1, meaning no way to tell.  */
+// OBSOLETE 
+// OBSOLETE #define FRAME_NUM_ARGS(fi)	(-1)
+// OBSOLETE 
+// OBSOLETE /* Return number of bytes at start of arglist that are not really args.  */
+// OBSOLETE 
+// OBSOLETE #define FRAME_ARGS_SKIP 0
+// OBSOLETE 
+// OBSOLETE /* Produce the positions of the saved registers in a stack frame.  */
+// OBSOLETE 
+// OBSOLETE #define FRAME_FIND_SAVED_REGS(frame_info_addr, sr) \
+// OBSOLETE 	frame_find_saved_regs (frame_info_addr, &sr)
+// OBSOLETE extern void frame_find_saved_regs ();	/* See arc-tdep.c */
+// OBSOLETE 
+// OBSOLETE 
+// OBSOLETE /* Things needed for making calls to functions in the inferior process */
+// OBSOLETE void arc_push_dummy_frame (void);
+// OBSOLETE #define PUSH_DUMMY_FRAME \
+// OBSOLETE 	arc_push_dummy_frame ()
+// OBSOLETE 
+// OBSOLETE /* Discard from the stack the innermost frame, restoring all registers.  */
+// OBSOLETE void arc_pop_frame (void);
+// OBSOLETE #define POP_FRAME \
+// OBSOLETE 	arc_pop_frame ()
+// OBSOLETE 
+// OBSOLETE /* This sequence of words is the instructions  bl xxxx, flag 1 */
+// OBSOLETE #define CALL_DUMMY { 0x28000000, 0x1fbe8001 }
+// OBSOLETE #define CALL_DUMMY_LENGTH 8
+// OBSOLETE 
+// OBSOLETE /* Start execution at beginning of dummy */
+// OBSOLETE #define CALL_DUMMY_START_OFFSET 0
+// OBSOLETE 
+// OBSOLETE /* Insert the specified number of args and function address
+// OBSOLETE    into a call sequence of the above form stored at 'dummyname'. */
+// OBSOLETE #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
+// OBSOLETE { \
+// OBSOLETE         int from, to, delta, loc; \
+// OBSOLETE         loc = (int)(read_register (SP_REGNUM) - CALL_DUMMY_LENGTH); \
+// OBSOLETE         from = loc + 4; \
+// OBSOLETE         to = (int)(fun); \
+// OBSOLETE         delta = (to - from) >> 2; \
+// OBSOLETE         *((char *)(dummyname) + 1) = (delta & 0x1); \
+// OBSOLETE         *((char *)(dummyname) + 2) = ((delta >> 1) & 0xff); \
+// OBSOLETE         *((char *)(dummyname) + 3) = ((delta >> 9) & 0xff); \
+// OBSOLETE         *((char *)(dummyname) + 4) = ((delta >> 17) & 0x7); \
+// OBSOLETE }
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index 11274ec..d0b13c8 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -43,7 +43,7 @@ alpha*-*-linux*)	gdb_target=alpha-linux ;;
 alpha*-*-freebsd*)	gdb_target=fbsd ;;
 alpha*-*-netbsd*)	gdb_target=nbsd ;;
 
-arc-*-*)		gdb_target=arc ;;
+# OBSOLETE arc-*-*)		gdb_target=arc ;;
 
 arm*-wince-pe)		gdb_target=wince ;;
 arm*-*-linux*)		gdb_target=linux