[deliverable/binutils-gdb.git] / gdb / d10v-tdep.c

/* Target-dependent code for MItsubishi D10V, for GDB.
   Copyright (C) 1996 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 "obstack.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "value.h"
#include "inferior.h"
#include "dis-asm.h"  

void d10v_frame_find_saved_regs PARAMS ((struct frame_info *fi, struct frame_saved_regs *fsr));

/* Discard from the stack the innermost frame,
   restoring all saved registers.  */

void
d10v_pop_frame ()
{
  struct frame_info *frame = get_current_frame ();
  CORE_ADDR fp, r13;
  int regnum;
  struct frame_saved_regs fsr;
  char raw_buffer[8];

  fp = FRAME_FP (frame);
  /* printf("pop_frame 0x%x\n",fp); */

  /* fill out fsr with the address of where each */
  /* register was stored in the frame */
  get_frame_saved_regs (frame, &fsr);
  
  /* r13 contains the old PC.  save it. */
  r13 = read_register (13);

  /* now update the current registers with the old values */
  for (regnum = A0_REGNUM; regnum < A0_REGNUM+2 ; regnum++)
    {
      if (fsr.regs[regnum])
	{
	  read_memory (fsr.regs[regnum] & 0xFFFF, raw_buffer, 8);
	  write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 8);
	}
    }
  for (regnum = 0; regnum < SP_REGNUM; regnum++)
    {
      if (fsr.regs[regnum])
	{
	  write_register (regnum, read_memory_integer (fsr.regs[regnum] & 0xFFFF, 2));
	}
    }
  if (fsr.regs[PSW_REGNUM])
    {
      write_register (PSW_REGNUM, read_memory_integer (fsr.regs[PSW_REGNUM] & 0xFFFF, 2));
    }

  /* PC is set to r13 */
  write_register (PC_REGNUM, r13);
  /* printf("setting stack to %x\n",fp - frame->size); */
  write_register (SP_REGNUM, fp - frame->size);
  flush_cached_frames ();
}

static int 
check_prologue (op)
     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;
}

CORE_ADDR
d10v_skip_prologue (pc)
     CORE_ADDR pc;
{
  unsigned long op;
  unsigned short op1, op2;

  if (target_read_memory (pc, (char *)&op, 4))
    return pc;			/* Can't access it -- assume no prologue. */

  while (1)
    {
      op = 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 */
	  op1 = (op & 0x3FFF8000) >> 15;
	  op2 = op & 0x7FFF;
	  if (!check_prologue(op1) || !check_prologue(op2))
	    break;
	}
      pc += 4;
    }
  return 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, and then
   INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.

   For us, the frame address is its stack pointer value, so we look up
   the function prologue to determine the caller's sp value, and return it.  */

CORE_ADDR
d10v_frame_chain (frame)
     struct frame_info *frame;
{
  struct frame_saved_regs fsr;
  /* printf("frame_chain %x\n",frame->frame); */
  d10v_frame_find_saved_regs (frame, &fsr);
  /* printf("pc=%x\n",fsr.regs[PC_REGNUM]);
  printf("fp=%x (%x)\n",fsr.regs[FP_REGNUM],read_memory_integer(fsr.regs[FP_REGNUM],2) & 0xffff); */
  return read_memory_integer(fsr.regs[FP_REGNUM],2) & 0xffff;
}  

static int next_addr;

static int 
prologue_find_regs (op, fsr, addr)
     unsigned short op;
     struct frame_saved_regs *fsr;
     CORE_ADDR addr;
{
  int n;

  /* st  rn, @-sp */
  if ((op & 0x7E1F) == 0x6C1F)
    {
      n = (op & 0x1E0) >> 5;
      next_addr -= 2;
      fsr->regs[n] = next_addr;
      return 1;
    }

  /* st2w  rn, @-sp */
  else if ((op & 0x7E3F) == 0x6E1F)
    {
      n = (op & 0x1E0) >> 5;
      next_addr -= 4;
      fsr->regs[n] = next_addr;
      fsr->regs[n+1] = next_addr+2;
      return 1;
    }

  /* subi  sp, n */
  if ((op & 0x7FE1) == 0x01E1)
    {
      n = (op & 0x1E) >> 1;
      if (n == 0)
	n = 16;
      next_addr -= n;
      return 1;
    }

  /* mv  r11, sp */
  if (op == 0x417E)
    return 1;

  /* nop */
  if (op == 0x5E00)
    return 1;

  /* st  rn, @sp */
  if ((op & 0x7E1F) == 0x681E)
    {
      n = (op & 0x1E0) >> 5;
      fsr->regs[n] = next_addr;
      return 1;
    }

  /* st2w  rn, @sp */
  if ((op & 0x7E3F) == 0x3A1E)
    {
      n = (op & 0x1E0) >> 5;
      fsr->regs[n] = next_addr;
      fsr->regs[n+1] = next_addr+2;
      return 1;
    }

  return 0;
}

/* Put here the code to store, into a struct frame_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. */
void
d10v_frame_find_saved_regs (fi, fsr)
     struct frame_info *fi;
     struct frame_saved_regs *fsr;
{
  CORE_ADDR fp, pc;
  unsigned long op;
  unsigned short op1, op2;
  int i;

  fp = fi->frame;
  memset (fsr, 0, sizeof (*fsr));
  next_addr = 0;

  pc = get_pc_function_start (fi->pc);

  while (1)
    {
      op = read_memory_integer (pc, 4);
      if ((op & 0xC0000000) == 0xC0000000)
	{
	  /* long instruction */
	  if ((op & 0x3FFF0000) == 0x01FF0000)
	    {
	      /* add3 sp,sp,n */
	      short n = op & 0xFFFF;
	      next_addr += n;
	    }
	  else if ((op & 0x3F0F0000) == 0x340F0000)
	    {
	      /* st  rn, @(offset,sp) */
	      short offset = op & 0xFFFF;
	      short n = (op >> 20) & 0xF;
	      fsr->regs[n] = next_addr + offset;
	    }
	  else if ((op & 0x3F1F0000) == 0x350F0000)
	    {
	      /* st2w  rn, @(offset,sp) */
	      short offset = op & 0xFFFF;
	      short n = (op >> 20) & 0xF;
	      fsr->regs[n] = next_addr + offset;
	      fsr->regs[n+1] = next_addr + offset + 2;
	    }
	  else
	    break;
	}
      else
	{
	  /* short instructions */
	  op1 = (op & 0x3FFF8000) >> 15;
	  op2 = op & 0x7FFF;
	  if (!prologue_find_regs(op1,fsr,pc) || !prologue_find_regs(op2,fsr,pc))
	    break;
	}
      pc += 4;
    }
  
  fi->size = -next_addr;
  fi->return_pc = read_register (13);

  for (i=0; i<NUM_REGS; i++)
    if (fsr->regs[i])
      {
	fsr->regs[i] = fp - (next_addr - fsr->regs[i]); 
	/* printf("register %d = *(%x) = %x\n",i,fsr->regs[i],read_memory_integer((fsr->regs[i]) & 0xffff, 2)); */
      }
}

void
d10v_init_extra_frame_info (fromleaf, fi)
     int fromleaf;
     struct frame_info *fi;
{
  struct frame_saved_regs dummy;
  /* printf("extra init %x  next=%x  pc=%x\n",fi->frame,fi->next,fi->pc); */

  /*   fi->pc = fi->next->return_pc; */
  d10v_frame_find_saved_regs (fi, &dummy); 
  /* printf("           %x  next=%x  pc=%x\n",fi->frame,fi->next,fi->pc); */
}

static void
show_regs (args, from_tty)
     char *args;
     int from_tty;
{
  long long num1, num2;
  printf_filtered ("PC=%04x (0x%x) PSW=%04x RPT_S=%04x RPT_E=%04x RPT_C=%04x\n",
                   read_register (PC_REGNUM), read_register (PC_REGNUM) << 2,
                   read_register (PSW_REGNUM),
                   read_register (24),
                   read_register (25),
                   read_register (23));
  printf_filtered ("R0-R7  %04x %04x %04x %04x %04x %04x %04x %04x\n",
                   read_register (0),
                   read_register (1),
                   read_register (2),
                   read_register (3),
                   read_register (4),
                   read_register (5),
                   read_register (6),
                   read_register (7));
  printf_filtered ("R8-R15 %04x %04x %04x %04x %04x %04x %04x %04x\n",
                   read_register (8), 
                   read_register (9),
                   read_register (10),
                   read_register (11),
                   read_register (12),
                   read_register (13),
                   read_register (14),
                   read_register (15));
  read_register_gen (A0_REGNUM, (char *)&num1);
  read_register_gen (A0_REGNUM+1, (char *)&num2);
  printf_filtered ("A0-A1  %010llx %010llx\n",num1, num2);
}              

void
_initialize_d10v_tdep ()
{
  struct cmd_list_element *c;
  tm_print_insn = print_insn_d10v;
  add_com ("regs", class_vars, show_regs, "Print all registers");
} 

CORE_ADDR
d10v_read_register_pid (regno, pid)
     int regno, pid;
{
  int save_pid;
  CORE_ADDR retval;

  if (pid == inferior_pid)
    return (read_register(regno)) << 2;

  save_pid = inferior_pid;
  inferior_pid = pid;
  retval = read_register (regno);
  inferior_pid = save_pid;
  return (retval << 2);
}

void
d10v_write_register_pid (regno, val, pid)
     int regno;
     LONGEST val;
     int pid;
{
  int save_pid;

  val >>= 2;

  if (pid == inferior_pid)
    {
      write_register (regno, val);
      return;
    }

  save_pid = inferior_pid;
  inferior_pid = pid;
  write_register (regno, val);
  inferior_pid = save_pid;
}
Commit	Line	Data
7b3fa778 MH	1	/* Target-dependent code for MItsubishi D10V, for GDB.
	2	Copyright (C) 1996 Free Software Foundation, Inc.
	3	This file is part of GDB.
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 2 of the License, or
	7	(at your option) any later version.
	8	This program is distributed in the hope that it will be useful,
	9	but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	GNU General Public License for more details.
	12	You should have received a copy of the GNU General Public License
	13	along with this program; if not, write to the Free Software
	14	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	15
	16	/* Contributed by Martin Hunt, hunt@cygnus.com */
	17
	18	#include "defs.h"
	19	#include "frame.h"
	20	#include "obstack.h"
	21	#include "symtab.h"
	22	#include "gdbtypes.h"
	23	#include "gdbcmd.h"
	24	#include "gdbcore.h"
	25	#include "value.h"
	26	#include "inferior.h"
	27	#include "dis-asm.h"
	28
e05bda9f MH	29	void d10v_frame_find_saved_regs PARAMS ((struct frame_info fi, struct frame_saved_regs fsr));
	30
	31	/* Discard from the stack the innermost frame,
	32	restoring all saved registers. */
	33
7b3fa778 MH	34	void
	35	d10v_pop_frame ()
	36	{
e05bda9f MH	37	struct frame_info *frame = get_current_frame ();
	38	CORE_ADDR fp, r13;
	39	int regnum;
	40	struct frame_saved_regs fsr;
	41	char raw_buffer[8];
	42
	43	fp = FRAME_FP (frame);
	44	/* printf("pop_frame 0x%x\n",fp); */
	45
	46	/* fill out fsr with the address of where each */
	47	/* register was stored in the frame */
	48	get_frame_saved_regs (frame, &fsr);
	49
	50	/* r13 contains the old PC. save it. */
	51	r13 = read_register (13);
	52
	53	/* now update the current registers with the old values */
	54	for (regnum = A0_REGNUM; regnum < A0_REGNUM+2 ; regnum++)
	55	{
	56	if (fsr.regs[regnum])
	57	{
	58	read_memory (fsr.regs[regnum] & 0xFFFF, raw_buffer, 8);
	59	write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 8);
	60	}
	61	}
	62	for (regnum = 0; regnum < SP_REGNUM; regnum++)
	63	{
	64	if (fsr.regs[regnum])
	65	{
	66	write_register (regnum, read_memory_integer (fsr.regs[regnum] & 0xFFFF, 2));
	67	}
	68	}
	69	if (fsr.regs[PSW_REGNUM])
	70	{
	71	write_register (PSW_REGNUM, read_memory_integer (fsr.regs[PSW_REGNUM] & 0xFFFF, 2));
	72	}
	73
	74	/* PC is set to r13 */
	75	write_register (PC_REGNUM, r13);
	76	/* printf("setting stack to %x\n",fp - frame->size); */
	77	write_register (SP_REGNUM, fp - frame->size);
	78	flush_cached_frames ();
	79	}
	80
	81	static int
	82	check_prologue (op)
	83	unsigned short op;
	84	{
	85	/* st rn, @-sp */
	86	if ((op & 0x7E1F) == 0x6C1F)
	87	return 1;
	88
	89	/* st2w rn, @-sp */
	90	if ((op & 0x7E3F) == 0x6E1F)
	91	return 1;
	92
	93	/* subi sp, n */
	94	if ((op & 0x7FE1) == 0x01E1)
	95	return 1;
	96
	97	/* mv r11, sp */
	98	if (op == 0x417E)
	99	return 1;
	100
101	/* nop */
102	if (op == 0x5E00)
103	return 1;
104
105	/* st rn, @sp */
106	if ((op & 0x7E1F) == 0x681E)
107	return 1;
108
109	/* st2w rn, @sp */
110	if ((op & 0x7E3F) == 0x3A1E)
111	return 1;
112
113
114	return 0;
7b3fa778 MH	115	}
	116
	117	CORE_ADDR
e05bda9f MH	118	d10v_skip_prologue (pc)
e05bda9f MH	119	CORE_ADDR pc;
7b3fa778	120	{
e05bda9f MH	121	unsigned long op;
	122	unsigned short op1, op2;
	123
	124	if (target_read_memory (pc, (char *)&op, 4))
	125	return pc; /* Can't access it -- assume no prologue. */
	126
	127	while (1)
	128	{
	129	op = read_memory_integer (pc, 4);
	130	if ((op & 0xC0000000) == 0xC0000000)
	131	{
	132	/* long instruction */
	133	if ( ((op & 0x3FFF0000) != 0x01FF0000) && /* add3 sp,sp,n */
	134	((op & 0x3F0F0000) != 0x340F0000) && /* st rn, @(offset,sp) */
	135	((op & 0x3F1F0000) != 0x350F0000)) /* st2w rn, @(offset,sp) */
	136	break;
	137	}
	138	else
	139	{
	140	/* short instructions */
	141	op1 = (op & 0x3FFF8000) >> 15;
	142	op2 = op & 0x7FFF;
	143	if (!check_prologue(op1) \|\| !check_prologue(op2))
	144	break;
	145	}
	146	pc += 4;
	147	}
	148	return pc;
7b3fa778 MH	149	}
7b3fa778 MH	150
e05bda9f MH	151	/* Given a GDB frame, determine the address of the calling function's frame.
	152	This will be used to create a new GDB frame struct, and then
	153	INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
	154
	155	For us, the frame address is its stack pointer value, so we look up
	156	the function prologue to determine the caller's sp value, and return it. */
	157
7b3fa778 MH	158	CORE_ADDR
	159	d10v_frame_chain (frame)
	160	struct frame_info *frame;
	161	{
e05bda9f MH	162	struct frame_saved_regs fsr;
	163	/* printf("frame_chain %x\n",frame->frame); */
	164	d10v_frame_find_saved_regs (frame, &fsr);
	165	/* printf("pc=%x\n",fsr.regs[PC_REGNUM]);
	166	printf("fp=%x (%x)\n",fsr.regs[FP_REGNUM],read_memory_integer(fsr.regs[FP_REGNUM],2) & 0xffff); */
	167	return read_memory_integer(fsr.regs[FP_REGNUM],2) & 0xffff;
7b3fa778 MH	168	}
7b3fa778 MH	169
e05bda9f MH	170	static int next_addr;
	171
	172	static int
	173	prologue_find_regs (op, fsr, addr)
	174	unsigned short op;
	175	struct frame_saved_regs *fsr;
	176	CORE_ADDR addr;
	177	{
	178	int n;
	179
	180	/* st rn, @-sp */
	181	if ((op & 0x7E1F) == 0x6C1F)
	182	{
	183	n = (op & 0x1E0) >> 5;
	184	next_addr -= 2;
	185	fsr->regs[n] = next_addr;
	186	return 1;
	187	}
	188
	189	/* st2w rn, @-sp */
	190	else if ((op & 0x7E3F) == 0x6E1F)
	191	{
	192	n = (op & 0x1E0) >> 5;
	193	next_addr -= 4;
	194	fsr->regs[n] = next_addr;
	195	fsr->regs[n+1] = next_addr+2;
	196	return 1;
	197	}
	198
	199	/* subi sp, n */
	200	if ((op & 0x7FE1) == 0x01E1)
	201	{
	202	n = (op & 0x1E) >> 1;
	203	if (n == 0)
	204	n = 16;
	205	next_addr -= n;
	206	return 1;
	207	}
	208
	209	/* mv r11, sp */
	210	if (op == 0x417E)
	211	return 1;
	212
	213	/* nop */
	214	if (op == 0x5E00)
	215	return 1;
	216
	217	/* st rn, @sp */
	218	if ((op & 0x7E1F) == 0x681E)
	219	{
	220	n = (op & 0x1E0) >> 5;
	221	fsr->regs[n] = next_addr;
	222	return 1;
	223	}
	224
	225	/* st2w rn, @sp */
	226	if ((op & 0x7E3F) == 0x3A1E)
	227	{
	228	n = (op & 0x1E0) >> 5;
	229	fsr->regs[n] = next_addr;
	230	fsr->regs[n+1] = next_addr+2;
	231	return 1;
	232	}
	233
234	return 0;
235	}
236
7b3fa778 MH	237	/* Put here the code to store, into a struct frame_saved_regs, the
	238	addresses of the saved registers of frame described by FRAME_INFO.
	239	This includes special registers such as pc and fp saved in special
	240	ways in the stack frame. sp is even more special: the address we
	241	return for it IS the sp for the next frame. */
	242	void
	243	d10v_frame_find_saved_regs (fi, fsr)
	244	struct frame_info *fi;
	245	struct frame_saved_regs *fsr;
e05bda9f MH	246	{
	247	CORE_ADDR fp, pc;
	248	unsigned long op;
	249	unsigned short op1, op2;
	250	int i;
	251
	252	fp = fi->frame;
	253	memset (fsr, 0, sizeof (*fsr));
	254	next_addr = 0;
	255
	256	pc = get_pc_function_start (fi->pc);
	257
	258	while (1)
	259	{
	260	op = read_memory_integer (pc, 4);
	261	if ((op & 0xC0000000) == 0xC0000000)
	262	{
	263	/* long instruction */
	264	if ((op & 0x3FFF0000) == 0x01FF0000)
	265	{
	266	/* add3 sp,sp,n */
	267	short n = op & 0xFFFF;
	268	next_addr += n;
	269	}
	270	else if ((op & 0x3F0F0000) == 0x340F0000)
	271	{
	272	/* st rn, @(offset,sp) */
	273	short offset = op & 0xFFFF;
	274	short n = (op >> 20) & 0xF;
	275	fsr->regs[n] = next_addr + offset;
	276	}
	277	else if ((op & 0x3F1F0000) == 0x350F0000)
	278	{
	279	/* st2w rn, @(offset,sp) */
	280	short offset = op & 0xFFFF;
	281	short n = (op >> 20) & 0xF;
	282	fsr->regs[n] = next_addr + offset;
	283	fsr->regs[n+1] = next_addr + offset + 2;
	284	}
	285	else
	286	break;
	287	}
	288	else
	289	{
	290	/* short instructions */
	291	op1 = (op & 0x3FFF8000) >> 15;
	292	op2 = op & 0x7FFF;
	293	if (!prologue_find_regs(op1,fsr,pc) \|\| !prologue_find_regs(op2,fsr,pc))
	294	break;
	295	}
	296	pc += 4;
	297	}
	298
	299	fi->size = -next_addr;
	300	fi->return_pc = read_register (13);
	301
	302	for (i=0; i<NUM_REGS; i++)
	303	if (fsr->regs[i])
	304	{
	305	fsr->regs[i] = fp - (next_addr - fsr->regs[i]);
	306	/* printf("register %d = (%x) = %x\n",i,fsr->regs[i],read_memory_integer((fsr->regs[i]) & 0xffff, 2)); /
	307	}
7b3fa778 MH	308	}
	309
	310	void
	311	d10v_init_extra_frame_info (fromleaf, fi)
	312	int fromleaf;
	313	struct frame_info *fi;
	314	{
	315	struct frame_saved_regs dummy;
e05bda9f MH	316	/* printf("extra init %x next=%x pc=%x\n",fi->frame,fi->next,fi->pc); */
	317
	318	/* fi->pc = fi->next->return_pc; */
	319	d10v_frame_find_saved_regs (fi, &dummy);
	320	/* printf(" %x next=%x pc=%x\n",fi->frame,fi->next,fi->pc); */
7b3fa778 MH	321	}
	322
	323	static void
	324	show_regs (args, from_tty)
	325	char *args;
	326	int from_tty;
	327	{
	328	long long num1, num2;
	329	printf_filtered ("PC=%04x (0x%x) PSW=%04x RPT_S=%04x RPT_E=%04x RPT_C=%04x\n",
	330	read_register (PC_REGNUM), read_register (PC_REGNUM) << 2,
	331	read_register (PSW_REGNUM),
	332	read_register (24),
	333	read_register (25),
	334	read_register (23));
	335	printf_filtered ("R0-R7 %04x %04x %04x %04x %04x %04x %04x %04x\n",
	336	read_register (0),
	337	read_register (1),
	338	read_register (2),
	339	read_register (3),
	340	read_register (4),
	341	read_register (5),
	342	read_register (6),
	343	read_register (7));
	344	printf_filtered ("R8-R15 %04x %04x %04x %04x %04x %04x %04x %04x\n",
	345	read_register (8),
	346	read_register (9),
	347	read_register (10),
	348	read_register (11),
	349	read_register (12),
	350	read_register (13),
	351	read_register (14),
	352	read_register (15));
	353	read_register_gen (A0_REGNUM, (char *)&num1);
	354	read_register_gen (A0_REGNUM+1, (char *)&num2);
	355	printf_filtered ("A0-A1 %010llx %010llx\n",num1, num2);
	356	}
	357
	358	void
	359	_initialize_d10v_tdep ()
	360	{
	361	struct cmd_list_element *c;
	362	tm_print_insn = print_insn_d10v;
	363	add_com ("regs", class_vars, show_regs, "Print all registers");
	364	}
	365
	366	CORE_ADDR
	367	d10v_read_register_pid (regno, pid)
	368	int regno, pid;
	369	{
	370	int save_pid;
	371	CORE_ADDR retval;
	372
	373	if (pid == inferior_pid)
	374	return (read_register(regno)) << 2;
	375
	376	save_pid = inferior_pid;
	377	inferior_pid = pid;
	378	retval = read_register (regno);
	379	inferior_pid = save_pid;
	380	return (retval << 2);
	381	}
	382
	383	void
	384	d10v_write_register_pid (regno, val, pid)
385	int regno;
386	LONGEST val;
387	int pid;
388	{
389	int save_pid;
390
391	val >>= 2;
392
393	if (pid == inferior_pid)
394	{
395	write_register (regno, val);
396	return;
397	}
398
399	save_pid = inferior_pid;
400	inferior_pid = pid;
401	write_register (regno, val);
402	inferior_pid = save_pid;
403	}