1/* Remote debugging interface for M32R/SDI.
2
3   Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
4
5   Contributed by Renesas Technology Co.
6   Written by Kei Sakamoto <sakamoto.kei@renesas.com>.
7
8   This file is part of GDB.
9
10   This program is free software; you can redistribute it and/or modify
11   it under the terms of the GNU General Public License as published by
12   the Free Software Foundation; either version 3 of the License, or
13   (at your option) any later version.
14
15   This program is distributed in the hope that it will be useful,
16   but WITHOUT ANY WARRANTY; without even the implied warranty of
17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18   GNU General Public License for more details.
19
20   You should have received a copy of the GNU General Public License
21   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23#include "defs.h"
24#include "gdbcmd.h"
25#include "gdbcore.h"
26#include "inferior.h"
27#include "target.h"
28#include "regcache.h"
29#include "gdb_string.h"
30#include <ctype.h>
31#include <signal.h>
32#ifdef __MINGW32__
33#include <winsock.h>
34#else
35#include <netinet/in.h>
36#endif
37#include <sys/types.h>
38#include <sys/time.h>
39#include <signal.h>
40#include <time.h>
41
42
43#include "serial.h"
44
45/* Descriptor for I/O to remote machine.  */
46
47static struct serial *sdi_desc = NULL;
48
49#define SDI_TIMEOUT 30
50
51
52#define SDIPORT 3232
53
54static char chip_name[64];
55
56static int step_mode;
57static unsigned long last_pc_addr = 0xffffffff;
58static unsigned char last_pc_addr_data[2];
59
60static int mmu_on = 0;
61
62static int use_ib_breakpoints = 1;
63
64#define MAX_BREAKPOINTS 1024
65static int max_ib_breakpoints;
66static unsigned long bp_address[MAX_BREAKPOINTS];
67static unsigned char bp_data[MAX_BREAKPOINTS][4];
68
69/* dbt -> nop */
70static const unsigned char dbt_bp_entry[] = {
71  0x10, 0xe0, 0x70, 0x00
72};
73
74#define MAX_ACCESS_BREAKS 4
75static int max_access_breaks;
76static unsigned long ab_address[MAX_ACCESS_BREAKS];
77static unsigned int ab_type[MAX_ACCESS_BREAKS];
78static unsigned int ab_size[MAX_ACCESS_BREAKS];
79static CORE_ADDR hit_watchpoint_addr = 0;
80
81static int interrupted = 0;
82
83/* Forward data declarations */
84extern struct target_ops m32r_ops;
85
86
87/* Commands */
88#define SDI_OPEN                 1
89#define SDI_CLOSE                2
90#define SDI_RELEASE              3
91#define SDI_READ_CPU_REG         4
92#define SDI_WRITE_CPU_REG        5
93#define SDI_READ_MEMORY          6
94#define SDI_WRITE_MEMORY         7
95#define SDI_EXEC_CPU             8
96#define SDI_STOP_CPU             9
97#define SDI_WAIT_FOR_READY      10
98#define SDI_GET_ATTR            11
99#define SDI_SET_ATTR            12
100#define SDI_STATUS              13
101
102/* Attributes */
103#define SDI_ATTR_NAME            1
104#define SDI_ATTR_BRK             2
105#define SDI_ATTR_ABRK            3
106#define SDI_ATTR_CACHE           4
107#define SDI_CACHE_TYPE_M32102    0
108#define SDI_CACHE_TYPE_CHAOS     1
109#define SDI_ATTR_MEM_ACCESS      5
110#define SDI_MEM_ACCESS_DEBUG_DMA 0
111#define SDI_MEM_ACCESS_MON_CODE  1
112
113/* Registers */
114#define SDI_REG_R0               0
115#define SDI_REG_R1               1
116#define SDI_REG_R2               2
117#define SDI_REG_R3               3
118#define SDI_REG_R4               4
119#define SDI_REG_R5               5
120#define SDI_REG_R6               6
121#define SDI_REG_R7               7
122#define SDI_REG_R8               8
123#define SDI_REG_R9               9
124#define SDI_REG_R10             10
125#define SDI_REG_R11             11
126#define SDI_REG_R12             12
127#define SDI_REG_FP              13
128#define SDI_REG_LR              14
129#define SDI_REG_SP              15
130#define SDI_REG_PSW             16
131#define SDI_REG_CBR             17
132#define SDI_REG_SPI             18
133#define SDI_REG_SPU             19
134#define SDI_REG_CR4             20
135#define SDI_REG_EVB             21
136#define SDI_REG_BPC             22
137#define SDI_REG_CR7             23
138#define SDI_REG_BBPSW           24
139#define SDI_REG_CR9             25
140#define SDI_REG_CR10            26
141#define SDI_REG_CR11            27
142#define SDI_REG_CR12            28
143#define SDI_REG_WR              29
144#define SDI_REG_BBPC            30
145#define SDI_REG_PBP             31
146#define SDI_REG_ACCH            32
147#define SDI_REG_ACCL            33
148#define SDI_REG_ACC1H           34
149#define SDI_REG_ACC1L           35
150
151
152/* Low level communication functions */
153
154/* Check an ack packet from the target */
155static int
156get_ack (void)
157{
158  int c;
159
160  if (!sdi_desc)
161    return -1;
162
163  c = serial_readchar (sdi_desc, SDI_TIMEOUT);
164
165  if (c < 0)
166    return -1;
167
168  if (c != '+')			/* error */
169    return -1;
170
171  return 0;
172}
173
174/* Send data to the target and check an ack packet */
175static int
176send_data (void *buf, int len)
177{
178  int ret;
179
180  if (!sdi_desc)
181    return -1;
182
183  if (serial_write (sdi_desc, buf, len) != 0)
184    return -1;
185
186  if (get_ack () == -1)
187    return -1;
188
189  return len;
190}
191
192/* Receive data from the target */
193static int
194recv_data (void *buf, int len)
195{
196  int total = 0;
197  int c;
198
199  if (!sdi_desc)
200    return -1;
201
202  while (total < len)
203    {
204      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
205
206      if (c < 0)
207	return -1;
208
209      ((unsigned char *) buf)[total++] = c;
210    }
211
212  return len;
213}
214
215/* Store unsigned long parameter on packet */
216static void
217store_long_parameter (void *buf, long val)
218{
219  val = htonl (val);
220  memcpy (buf, &val, 4);
221}
222
223static int
224send_cmd (unsigned char cmd)
225{
226  unsigned char buf[1];
227  buf[0] = cmd;
228  return send_data (buf, 1);
229}
230
231static int
232send_one_arg_cmd (unsigned char cmd, unsigned char arg1)
233{
234  unsigned char buf[2];
235  buf[0] = cmd;
236  buf[1] = arg1;
237  return send_data (buf, 2);
238}
239
240static int
241send_two_arg_cmd (unsigned char cmd, unsigned char arg1, unsigned long arg2)
242{
243  unsigned char buf[6];
244  buf[0] = cmd;
245  buf[1] = arg1;
246  store_long_parameter (buf + 2, arg2);
247  return send_data (buf, 6);
248}
249
250static int
251send_three_arg_cmd (unsigned char cmd, unsigned long arg1, unsigned long arg2,
252		    unsigned long arg3)
253{
254  unsigned char buf[13];
255  buf[0] = cmd;
256  store_long_parameter (buf + 1, arg1);
257  store_long_parameter (buf + 5, arg2);
258  store_long_parameter (buf + 9, arg3);
259  return send_data (buf, 13);
260}
261
262static unsigned char
263recv_char_data (void)
264{
265  unsigned char val;
266  recv_data (&val, 1);
267  return val;
268}
269
270static unsigned long
271recv_long_data (void)
272{
273  unsigned long val;
274  recv_data (&val, 4);
275  return ntohl (val);
276}
277
278
279/* Check if MMU is on */
280static void
281check_mmu_status (void)
282{
283  unsigned long val;
284
285  /* Read PC address */
286  if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC) == -1)
287    return;
288  val = recv_long_data ();
289  if ((val & 0xc0000000) == 0x80000000)
290    {
291      mmu_on = 1;
292      return;
293    }
294
295  /* Read EVB address */
296  if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_EVB) == -1)
297    return;
298  val = recv_long_data ();
299  if ((val & 0xc0000000) == 0x80000000)
300    {
301      mmu_on = 1;
302      return;
303    }
304
305  mmu_on = 0;
306}
307
308
309/* This is called not only when we first attach, but also when the
310   user types "run" after having attached.  */
311static void
312m32r_create_inferior (char *execfile, char *args, char **env, int from_tty)
313{
314  CORE_ADDR entry_pt;
315
316  if (args && *args)
317    error (_("Cannot pass arguments to remote STDEBUG process"));
318
319  if (execfile == 0 || exec_bfd == 0)
320    error (_("No executable file specified"));
321
322  if (remote_debug)
323    fprintf_unfiltered (gdb_stdlog, "m32r_create_inferior(%s,%s)\n", execfile,
324			args);
325
326  entry_pt = bfd_get_start_address (exec_bfd);
327
328  /* The "process" (board) is already stopped awaiting our commands, and
329     the program is already downloaded.  We just set its PC and go.  */
330
331  clear_proceed_status ();
332
333  /* Tell wait_for_inferior that we've started a new process.  */
334  init_wait_for_inferior ();
335
336  /* Set up the "saved terminal modes" of the inferior
337     based on what modes we are starting it with.  */
338  target_terminal_init ();
339
340  /* Install inferior's terminal modes.  */
341  target_terminal_inferior ();
342
343  write_pc (entry_pt);
344}
345
346/* Open a connection to a remote debugger.
347   NAME is the filename used for communication.  */
348
349static void
350m32r_open (char *args, int from_tty)
351{
352  struct hostent *host_ent;
353  struct sockaddr_in server_addr;
354  char *port_str, hostname[256];
355  int port;
356  int i, n;
357  int yes = 1;
358
359  if (remote_debug)
360    fprintf_unfiltered (gdb_stdlog, "m32r_open(%d)\n", from_tty);
361
362  target_preopen (from_tty);
363
364  push_target (&m32r_ops);
365
366  if (args == NULL)
367    sprintf (hostname, "localhost:%d", SDIPORT);
368  else
369    {
370      port_str = strchr (args, ':');
371      if (port_str == NULL)
372	sprintf (hostname, "%s:%d", args, SDIPORT);
373      else
374	strcpy (hostname, args);
375    }
376
377  sdi_desc = serial_open (hostname);
378  if (!sdi_desc)
379    error (_("Connection refused."));
380
381  if (get_ack () == -1)
382    error (_("Cannot connect to SDI target."));
383
384  if (send_cmd (SDI_OPEN) == -1)
385    error (_("Cannot connect to SDI target."));
386
387  /* Get maximum number of ib breakpoints */
388  send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_BRK);
389  max_ib_breakpoints = recv_char_data ();
390  if (remote_debug)
391    printf_filtered ("Max IB Breakpoints = %d\n", max_ib_breakpoints);
392
393  /* Initialize breakpoints. */
394  for (i = 0; i < MAX_BREAKPOINTS; i++)
395    bp_address[i] = 0xffffffff;
396
397  /* Get maximum number of access breaks. */
398  send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_ABRK);
399  max_access_breaks = recv_char_data ();
400  if (remote_debug)
401    printf_filtered ("Max Access Breaks = %d\n", max_access_breaks);
402
403  /* Initialize access breask. */
404  for (i = 0; i < MAX_ACCESS_BREAKS; i++)
405    ab_address[i] = 0x00000000;
406
407  check_mmu_status ();
408
409  /* Get the name of chip on target board. */
410  send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_NAME);
411  recv_data (chip_name, 64);
412
413  if (from_tty)
414    printf_filtered ("Remote %s connected to %s\n", target_shortname,
415		     chip_name);
416}
417
418/* Close out all files and local state before this target loses control. */
419
420static void
421m32r_close (int quitting)
422{
423  if (remote_debug)
424    fprintf_unfiltered (gdb_stdlog, "m32r_close(%d)\n", quitting);
425
426  if (sdi_desc)
427    {
428      send_cmd (SDI_CLOSE);
429      serial_close (sdi_desc);
430      sdi_desc = NULL;
431    }
432
433  inferior_ptid = null_ptid;
434  return;
435}
436
437/* Tell the remote machine to resume.  */
438
439static void
440m32r_resume (ptid_t ptid, int step, enum target_signal sig)
441{
442  unsigned long pc_addr, bp_addr, ab_addr;
443  int ib_breakpoints;
444  unsigned char buf[13];
445  int i;
446
447  if (remote_debug)
448    {
449      if (step)
450	fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(step)\n");
451      else
452	fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(cont)\n");
453    }
454
455  check_mmu_status ();
456
457  pc_addr = read_pc ();
458  if (remote_debug)
459    fprintf_unfiltered (gdb_stdlog, "pc <= 0x%lx\n", pc_addr);
460
461  /* At pc address there is a parallel instruction with +2 offset,
462     so we have to make it a serial instruction or avoid it. */
463  if (pc_addr == last_pc_addr)
464    {
465      /* Avoid a parallel nop. */
466      if (last_pc_addr_data[0] == 0xf0 && last_pc_addr_data[1] == 0x00)
467	{
468	  pc_addr += 2;
469	  /* Now we can forget this instruction. */
470	  last_pc_addr = 0xffffffff;
471	}
472      /* Clear a parallel bit. */
473      else
474	{
475	  buf[0] = SDI_WRITE_MEMORY;
476	  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
477	    store_long_parameter (buf + 1, pc_addr);
478	  else
479	    store_long_parameter (buf + 1, pc_addr - 1);
480	  store_long_parameter (buf + 5, 1);
481	  buf[9] = last_pc_addr_data[0] & 0x7f;
482	  send_data (buf, 10);
483	}
484    }
485
486  /* Set PC. */
487  send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
488
489  /* step mode. */
490  step_mode = step;
491  if (step)
492    {
493      /* Set PBP. */
494      send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, pc_addr | 1);
495    }
496  else
497    {
498      /* Unset PBP. */
499      send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, 0x00000000);
500    }
501
502  if (use_ib_breakpoints)
503    ib_breakpoints = max_ib_breakpoints;
504  else
505    ib_breakpoints = 0;
506
507  /* Set ib breakpoints. */
508  for (i = 0; i < ib_breakpoints; i++)
509    {
510      bp_addr = bp_address[i];
511
512      if (bp_addr == 0xffffffff)
513	continue;
514
515      /* Set PBP. */
516      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
517	send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
518			    0x00000006);
519      else
520	send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
521			    0x06000000);
522
523      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8080 + 4 * i, 4, bp_addr);
524    }
525
526  /* Set dbt breakpoints. */
527  for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
528    {
529      bp_addr = bp_address[i];
530
531      if (bp_addr == 0xffffffff)
532	continue;
533
534      if (!mmu_on)
535	bp_addr &= 0x7fffffff;
536
537      /* Write DBT instruction. */
538      buf[0] = SDI_WRITE_MEMORY;
539      store_long_parameter (buf + 1, (bp_addr & 0xfffffffc));
540      store_long_parameter (buf + 5, 4);
541      if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
542	{
543	  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
544	    {
545	      buf[9] = dbt_bp_entry[0];
546	      buf[10] = dbt_bp_entry[1];
547	      buf[11] = dbt_bp_entry[2];
548	      buf[12] = dbt_bp_entry[3];
549	    }
550	  else
551	    {
552	      buf[9] = dbt_bp_entry[3];
553	      buf[10] = dbt_bp_entry[2];
554	      buf[11] = dbt_bp_entry[1];
555	      buf[12] = dbt_bp_entry[0];
556	    }
557	}
558      else
559	{
560	  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
561	    {
562	      if ((bp_addr & 2) == 0)
563		{
564		  buf[9] = dbt_bp_entry[0];
565		  buf[10] = dbt_bp_entry[1];
566		  buf[11] = bp_data[i][2] & 0x7f;
567		  buf[12] = bp_data[i][3];
568		}
569	      else
570		{
571		  buf[9] = bp_data[i][0];
572		  buf[10] = bp_data[i][1];
573		  buf[11] = dbt_bp_entry[0];
574		  buf[12] = dbt_bp_entry[1];
575		}
576	    }
577	  else
578	    {
579	      if ((bp_addr & 2) == 0)
580		{
581		  buf[9] = bp_data[i][0];
582		  buf[10] = bp_data[i][1] & 0x7f;
583		  buf[11] = dbt_bp_entry[1];
584		  buf[12] = dbt_bp_entry[0];
585		}
586	      else
587		{
588		  buf[9] = dbt_bp_entry[1];
589		  buf[10] = dbt_bp_entry[0];
590		  buf[11] = bp_data[i][2];
591		  buf[12] = bp_data[i][3];
592		}
593	    }
594	}
595      send_data (buf, 13);
596    }
597
598  /* Set access breaks. */
599  for (i = 0; i < max_access_breaks; i++)
600    {
601      ab_addr = ab_address[i];
602
603      if (ab_addr == 0x00000000)
604	continue;
605
606      /* DBC register */
607      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
608	{
609	  switch (ab_type[i])
610	    {
611	    case 0:		/* write watch */
612	      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
613				  0x00000086);
614	      break;
615	    case 1:		/* read watch */
616	      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
617				  0x00000046);
618	      break;
619	    case 2:		/* access watch */
620	      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
621				  0x00000006);
622	      break;
623	    }
624	}
625      else
626	{
627	  switch (ab_type[i])
628	    {
629	    case 0:		/* write watch */
630	      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
631				  0x86000000);
632	      break;
633	    case 1:		/* read watch */
634	      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
635				  0x46000000);
636	      break;
637	    case 2:		/* access watch */
638	      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
639				  0x06000000);
640	      break;
641	    }
642	}
643
644      /* DBAH register */
645      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8180 + 4 * i, 4, ab_addr);
646
647      /* DBAL register */
648      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8200 + 4 * i, 4,
649			  0xffffffff);
650
651      /* DBD register */
652      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8280 + 4 * i, 4,
653			  0x00000000);
654
655      /* DBDM register */
656      send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8300 + 4 * i, 4,
657			  0x00000000);
658    }
659
660  /* Resume program. */
661  send_cmd (SDI_EXEC_CPU);
662
663  /* Without this, some commands which require an active target (such as kill)
664     won't work.  This variable serves (at least) double duty as both the pid
665     of the target process (if it has such), and as a flag indicating that a
666     target is active.  These functions should be split out into seperate
667     variables, especially since GDB will someday have a notion of debugging
668     several processes.  */
669  inferior_ptid = pid_to_ptid (32);
670
671  return;
672}
673
674/* Wait until the remote machine stops, then return,
675   storing status in STATUS just as `wait' would.  */
676
677static void
678gdb_cntrl_c (int signo)
679{
680  if (remote_debug)
681    fprintf_unfiltered (gdb_stdlog, "interrupt\n");
682  interrupted = 1;
683}
684
685static ptid_t
686m32r_wait (ptid_t ptid, struct target_waitstatus *status)
687{
688  static RETSIGTYPE (*prev_sigint) ();
689  unsigned long bp_addr, pc_addr;
690  int ib_breakpoints;
691  long i;
692  unsigned char buf[13];
693  unsigned long val;
694  int ret, c;
695
696  if (remote_debug)
697    fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
698
699  status->kind = TARGET_WAITKIND_EXITED;
700  status->value.sig = 0;
701
702  interrupted = 0;
703  prev_sigint = signal (SIGINT, gdb_cntrl_c);
704
705  /* Wait for ready */
706  buf[0] = SDI_WAIT_FOR_READY;
707  if (serial_write (sdi_desc, buf, 1) != 0)
708    error (_("Remote connection closed"));
709
710  while (1)
711    {
712      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
713      if (c < 0)
714	error (_("Remote connection closed"));
715
716      if (c == '-')		/* error */
717	{
718	  status->kind = TARGET_WAITKIND_STOPPED;
719	  status->value.sig = TARGET_SIGNAL_HUP;
720	  return inferior_ptid;
721	}
722      else if (c == '+')	/* stopped */
723	break;
724
725      if (interrupted)
726	ret = serial_write (sdi_desc, "!", 1);	/* packet to interrupt */
727      else
728	ret = serial_write (sdi_desc, ".", 1);	/* packet to wait */
729      if (ret != 0)
730	error (_("Remote connection closed"));
731    }
732
733  status->kind = TARGET_WAITKIND_STOPPED;
734  if (interrupted)
735    status->value.sig = TARGET_SIGNAL_INT;
736  else
737    status->value.sig = TARGET_SIGNAL_TRAP;
738
739  interrupted = 0;
740  signal (SIGINT, prev_sigint);
741
742  check_mmu_status ();
743
744  /* Recover parallel bit. */
745  if (last_pc_addr != 0xffffffff)
746    {
747      buf[0] = SDI_WRITE_MEMORY;
748      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
749	store_long_parameter (buf + 1, last_pc_addr);
750      else
751	store_long_parameter (buf + 1, last_pc_addr - 1);
752      store_long_parameter (buf + 5, 1);
753      buf[9] = last_pc_addr_data[0];
754      send_data (buf, 10);
755      last_pc_addr = 0xffffffff;
756    }
757
758  if (use_ib_breakpoints)
759    ib_breakpoints = max_ib_breakpoints;
760  else
761    ib_breakpoints = 0;
762
763  /* Set back pc by 2 if m32r is stopped with dbt. */
764  last_pc_addr = 0xffffffff;
765  send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC);
766  pc_addr = recv_long_data () - 2;
767  for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
768    {
769      if (pc_addr == bp_address[i])
770	{
771	  send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
772
773	  /* If there is a parallel instruction with +2 offset at pc
774	     address, we have to take care of it later. */
775	  if ((pc_addr & 0x2) != 0)
776	    {
777	      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
778		{
779		  if ((bp_data[i][2] & 0x80) != 0)
780		    {
781		      last_pc_addr = pc_addr;
782		      last_pc_addr_data[0] = bp_data[i][2];
783		      last_pc_addr_data[1] = bp_data[i][3];
784		    }
785		}
786	      else
787		{
788		  if ((bp_data[i][1] & 0x80) != 0)
789		    {
790		      last_pc_addr = pc_addr;
791		      last_pc_addr_data[0] = bp_data[i][1];
792		      last_pc_addr_data[1] = bp_data[i][0];
793		    }
794		}
795	    }
796	  break;
797	}
798    }
799
800  /* Remove ib breakpoints. */
801  for (i = 0; i < ib_breakpoints; i++)
802    {
803      if (bp_address[i] != 0xffffffff)
804	send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
805			    0x00000000);
806    }
807  /* Remove dbt breakpoints. */
808  for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
809    {
810      bp_addr = bp_address[i];
811      if (bp_addr != 0xffffffff)
812	{
813	  if (!mmu_on)
814	    bp_addr &= 0x7fffffff;
815	  buf[0] = SDI_WRITE_MEMORY;
816	  store_long_parameter (buf + 1, bp_addr & 0xfffffffc);
817	  store_long_parameter (buf + 5, 4);
818	  buf[9] = bp_data[i][0];
819	  buf[10] = bp_data[i][1];
820	  buf[11] = bp_data[i][2];
821	  buf[12] = bp_data[i][3];
822	  send_data (buf, 13);
823	}
824    }
825
826  /* Remove access breaks. */
827  hit_watchpoint_addr = 0;
828  for (i = 0; i < max_access_breaks; i++)
829    {
830      if (ab_address[i] != 0x00000000)
831	{
832	  buf[0] = SDI_READ_MEMORY;
833	  store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
834	  store_long_parameter (buf + 5, 4);
835	  serial_write (sdi_desc, buf, 9);
836	  c = serial_readchar (sdi_desc, SDI_TIMEOUT);
837	  if (c != '-' && recv_data (buf, 4) != -1)
838	    {
839	      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
840		{
841		  if ((buf[3] & 0x1) == 0x1)
842		    hit_watchpoint_addr = ab_address[i];
843		}
844	      else
845		{
846		  if ((buf[0] & 0x1) == 0x1)
847		    hit_watchpoint_addr = ab_address[i];
848		}
849	    }
850
851	  send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
852			      0x00000000);
853	}
854    }
855
856  if (remote_debug)
857    fprintf_unfiltered (gdb_stdlog, "pc => 0x%lx\n", pc_addr);
858
859  return inferior_ptid;
860}
861
862/* Terminate the open connection to the remote debugger.
863   Use this when you want to detach and do something else
864   with your gdb.  */
865static void
866m32r_detach (char *args, int from_tty)
867{
868  if (remote_debug)
869    fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
870
871  m32r_resume (inferior_ptid, 0, 0);
872
873  /* calls m32r_close to do the real work */
874  pop_target ();
875  if (from_tty)
876    fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
877			target_shortname);
878}
879
880/* Return the id of register number REGNO. */
881
882static int
883get_reg_id (int regno)
884{
885  switch (regno)
886    {
887    case 20:
888      return SDI_REG_BBPC;
889    case 21:
890      return SDI_REG_BPC;
891    case 22:
892      return SDI_REG_ACCL;
893    case 23:
894      return SDI_REG_ACCH;
895    case 24:
896      return SDI_REG_EVB;
897    }
898
899  return regno;
900}
901
902/* Read the remote registers into the block REGS.  */
903
904static void m32r_fetch_register (struct regcache *, int);
905
906static void
907m32r_fetch_registers (struct regcache *regcache)
908{
909  int regno;
910
911  for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
912    m32r_fetch_register (regcache, regno);
913}
914
915/* Fetch register REGNO, or all registers if REGNO is -1.
916   Returns errno value.  */
917static void
918m32r_fetch_register (struct regcache *regcache, int regno)
919{
920  unsigned long val, val2, regid;
921
922  if (regno == -1)
923    m32r_fetch_registers (regcache);
924  else
925    {
926      char buffer[MAX_REGISTER_SIZE];
927
928      regid = get_reg_id (regno);
929      send_one_arg_cmd (SDI_READ_CPU_REG, regid);
930      val = recv_long_data ();
931
932      if (regid == SDI_REG_PSW)
933	{
934	  send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
935	  val2 = recv_long_data ();
936	  val = ((0x00cf & val2) << 8) | ((0xcf00 & val) >> 8);
937	}
938
939      if (remote_debug)
940	fprintf_unfiltered (gdb_stdlog, "m32r_fetch_register(%d,0x%08lx)\n",
941			    regno, val);
942
943      /* We got the number the register holds, but gdb expects to see a
944         value in the target byte ordering.  */
945      store_unsigned_integer (buffer, 4, val);
946      regcache_raw_supply (regcache, regno, buffer);
947    }
948  return;
949}
950
951/* Store the remote registers from the contents of the block REGS.  */
952
953static void m32r_store_register (struct regcache *, int);
954
955static void
956m32r_store_registers (struct regcache *regcache)
957{
958  int regno;
959
960  for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
961    m32r_store_register (regcache, regno);
962
963  registers_changed ();
964}
965
966/* Store register REGNO, or all if REGNO == 0.
967   Return errno value.  */
968static void
969m32r_store_register (struct regcache *regcache, int regno)
970{
971  int regid;
972  ULONGEST regval, tmp;
973
974  if (regno == -1)
975    m32r_store_registers (regcache);
976  else
977    {
978      regcache_cooked_read_unsigned (regcache, regno, &regval);
979      regid = get_reg_id (regno);
980
981      if (regid == SDI_REG_PSW)
982	{
983	  unsigned long psw, bbpsw;
984
985	  send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_PSW);
986	  psw = recv_long_data ();
987
988	  send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
989	  bbpsw = recv_long_data ();
990
991	  tmp = (0x00cf & psw) | ((0x00cf & regval) << 8);
992	  send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PSW, tmp);
993
994	  tmp = (0x0030 & bbpsw) | ((0xcf00 & regval) >> 8);
995	  send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BBPSW, tmp);
996	}
997      else
998	{
999	  send_two_arg_cmd (SDI_WRITE_CPU_REG, regid, regval);
1000	}
1001
1002      if (remote_debug)
1003	fprintf_unfiltered (gdb_stdlog, "m32r_store_register(%d,0x%08lu)\n",
1004			    regno, (unsigned long) regval);
1005    }
1006}
1007
1008/* Get ready to modify the registers array.  On machines which store
1009   individual registers, this doesn't need to do anything.  On machines
1010   which store all the registers in one fell swoop, this makes sure
1011   that registers contains all the registers from the program being
1012   debugged.  */
1013
1014static void
1015m32r_prepare_to_store (struct regcache *regcache)
1016{
1017  /* Do nothing, since we can store individual regs */
1018  if (remote_debug)
1019    fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
1020}
1021
1022static void
1023m32r_files_info (struct target_ops *target)
1024{
1025  char *file = "nothing";
1026
1027  if (exec_bfd)
1028    {
1029      file = bfd_get_filename (exec_bfd);
1030      printf_filtered ("\tAttached to %s running program %s\n",
1031		       chip_name, file);
1032    }
1033}
1034
1035/* Read/Write memory.  */
1036static int
1037m32r_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1038		  int write,
1039		  struct mem_attrib *attrib, struct target_ops *target)
1040{
1041  unsigned long taddr;
1042  unsigned char buf[0x2000];
1043  int ret, c;
1044
1045  taddr = memaddr;
1046
1047  if (!mmu_on)
1048    {
1049      if ((taddr & 0xa0000000) == 0x80000000)
1050	taddr &= 0x7fffffff;
1051    }
1052
1053  if (remote_debug)
1054    {
1055      if (write)
1056	fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%08lx,%d,write)\n",
1057			    memaddr, len);
1058      else
1059	fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%08lx,%d,read)\n",
1060			    memaddr, len);
1061    }
1062
1063  if (write)
1064    {
1065      buf[0] = SDI_WRITE_MEMORY;
1066      store_long_parameter (buf + 1, taddr);
1067      store_long_parameter (buf + 5, len);
1068      if (len < 0x1000)
1069	{
1070	  memcpy (buf + 9, myaddr, len);
1071	  ret = send_data (buf, len + 9) - 9;
1072	}
1073      else
1074	{
1075	  if (serial_write (sdi_desc, buf, 9) != 0)
1076	    {
1077	      if (remote_debug)
1078		fprintf_unfiltered (gdb_stdlog,
1079				    "m32r_xfer_memory() failed\n");
1080	      return 0;
1081	    }
1082	  ret = send_data (myaddr, len);
1083	}
1084    }
1085  else
1086    {
1087      buf[0] = SDI_READ_MEMORY;
1088      store_long_parameter (buf + 1, taddr);
1089      store_long_parameter (buf + 5, len);
1090      if (serial_write (sdi_desc, buf, 9) != 0)
1091	{
1092	  if (remote_debug)
1093	    fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1094	  return 0;
1095	}
1096
1097      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1098      if (c < 0 || c == '-')
1099	{
1100	  if (remote_debug)
1101	    fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1102	  return 0;
1103	}
1104
1105      ret = recv_data (myaddr, len);
1106    }
1107
1108  if (ret <= 0)
1109    {
1110      if (remote_debug)
1111	fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() fails\n");
1112      return 0;
1113    }
1114
1115  return ret;
1116}
1117
1118static void
1119m32r_kill (void)
1120{
1121  if (remote_debug)
1122    fprintf_unfiltered (gdb_stdlog, "m32r_kill()\n");
1123
1124  inferior_ptid = null_ptid;
1125
1126  return;
1127}
1128
1129/* Clean up when a program exits.
1130
1131   The program actually lives on in the remote processor's RAM, and may be
1132   run again without a download.  Don't leave it full of breakpoint
1133   instructions.  */
1134
1135static void
1136m32r_mourn_inferior (void)
1137{
1138  if (remote_debug)
1139    fprintf_unfiltered (gdb_stdlog, "m32r_mourn_inferior()\n");
1140
1141  remove_breakpoints ();
1142  generic_mourn_inferior ();
1143}
1144
1145static int
1146m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
1147{
1148  CORE_ADDR addr = bp_tgt->placed_address;
1149  int ib_breakpoints;
1150  unsigned char buf[13];
1151  int i, c;
1152
1153  if (remote_debug)
1154    fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%08lx,...)\n",
1155			addr);
1156
1157  if (use_ib_breakpoints)
1158    ib_breakpoints = max_ib_breakpoints;
1159  else
1160    ib_breakpoints = 0;
1161
1162  for (i = 0; i < MAX_BREAKPOINTS; i++)
1163    {
1164      if (bp_address[i] == 0xffffffff)
1165	{
1166	  bp_address[i] = addr;
1167	  if (i >= ib_breakpoints)
1168	    {
1169	      buf[0] = SDI_READ_MEMORY;
1170	      if (mmu_on)
1171		store_long_parameter (buf + 1, addr & 0xfffffffc);
1172	      else
1173		store_long_parameter (buf + 1, addr & 0x7ffffffc);
1174	      store_long_parameter (buf + 5, 4);
1175	      serial_write (sdi_desc, buf, 9);
1176	      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1177	      if (c != '-')
1178		recv_data (bp_data[i], 4);
1179	    }
1180	  return 0;
1181	}
1182    }
1183
1184  error (_("Too many breakpoints"));
1185  return 1;
1186}
1187
1188static int
1189m32r_remove_breakpoint (struct bp_target_info *bp_tgt)
1190{
1191  CORE_ADDR addr = bp_tgt->placed_address;
1192  int i;
1193
1194  if (remote_debug)
1195    fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%08lx)\n",
1196			addr);
1197
1198  for (i = 0; i < MAX_BREAKPOINTS; i++)
1199    {
1200      if (bp_address[i] == addr)
1201	{
1202	  bp_address[i] = 0xffffffff;
1203	  break;
1204	}
1205    }
1206
1207  return 0;
1208}
1209
1210static void
1211m32r_load (char *args, int from_tty)
1212{
1213  struct cleanup *old_chain;
1214  asection *section;
1215  bfd *pbfd;
1216  bfd_vma entry;
1217  char *filename;
1218  int quiet;
1219  int nostart;
1220  struct timeval start_time, end_time;
1221  unsigned long data_count;	/* Number of bytes transferred to memory */
1222  int ret;
1223  static RETSIGTYPE (*prev_sigint) ();
1224
1225  /* for direct tcp connections, we can do a fast binary download */
1226  quiet = 0;
1227  nostart = 0;
1228  filename = NULL;
1229
1230  while (*args != '\000')
1231    {
1232      char *arg;
1233
1234      while (isspace (*args))
1235	args++;
1236
1237      arg = args;
1238
1239      while ((*args != '\000') && !isspace (*args))
1240	args++;
1241
1242      if (*args != '\000')
1243	*args++ = '\000';
1244
1245      if (*arg != '-')
1246	filename = arg;
1247      else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
1248	quiet = 1;
1249      else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
1250	nostart = 1;
1251      else
1252	error (_("Unknown option `%s'"), arg);
1253    }
1254
1255  if (!filename)
1256    filename = get_exec_file (1);
1257
1258  pbfd = bfd_openr (filename, gnutarget);
1259  if (pbfd == NULL)
1260    {
1261      perror_with_name (filename);
1262      return;
1263    }
1264  old_chain = make_cleanup_bfd_close (pbfd);
1265
1266  if (!bfd_check_format (pbfd, bfd_object))
1267    error (_("\"%s\" is not an object file: %s"), filename,
1268	   bfd_errmsg (bfd_get_error ()));
1269
1270  gettimeofday (&start_time, NULL);
1271  data_count = 0;
1272
1273  interrupted = 0;
1274  prev_sigint = signal (SIGINT, gdb_cntrl_c);
1275
1276  for (section = pbfd->sections; section; section = section->next)
1277    {
1278      if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
1279	{
1280	  bfd_vma section_address;
1281	  bfd_size_type section_size;
1282	  file_ptr fptr;
1283	  int n;
1284
1285	  section_address = bfd_section_lma (pbfd, section);
1286	  section_size = bfd_get_section_size (section);
1287
1288	  if (!mmu_on)
1289	    {
1290	      if ((section_address & 0xa0000000) == 0x80000000)
1291		section_address &= 0x7fffffff;
1292	    }
1293
1294	  if (!quiet)
1295	    printf_filtered ("[Loading section %s at 0x%lx (%d bytes)]\n",
1296			     bfd_get_section_name (pbfd, section),
1297			     section_address, (int) section_size);
1298
1299	  fptr = 0;
1300
1301	  data_count += section_size;
1302
1303	  n = 0;
1304	  while (section_size > 0)
1305	    {
1306	      char unsigned buf[0x1000 + 9];
1307	      int count;
1308
1309	      count = min (section_size, 0x1000);
1310
1311	      buf[0] = SDI_WRITE_MEMORY;
1312	      store_long_parameter (buf + 1, section_address);
1313	      store_long_parameter (buf + 5, count);
1314
1315	      bfd_get_section_contents (pbfd, section, buf + 9, fptr, count);
1316	      if (send_data (buf, count + 9) <= 0)
1317		error (_("Error while downloading %s section."),
1318		       bfd_get_section_name (pbfd, section));
1319
1320	      if (!quiet)
1321		{
1322		  printf_unfiltered (".");
1323		  if (n++ > 60)
1324		    {
1325		      printf_unfiltered ("\n");
1326		      n = 0;
1327		    }
1328		  gdb_flush (gdb_stdout);
1329		}
1330
1331	      section_address += count;
1332	      fptr += count;
1333	      section_size -= count;
1334
1335	      if (interrupted)
1336		break;
1337	    }
1338
1339	  if (!quiet && !interrupted)
1340	    {
1341	      printf_unfiltered ("done.\n");
1342	      gdb_flush (gdb_stdout);
1343	    }
1344	}
1345
1346      if (interrupted)
1347	{
1348	  printf_unfiltered ("Interrupted.\n");
1349	  break;
1350	}
1351    }
1352
1353  interrupted = 0;
1354  signal (SIGINT, prev_sigint);
1355
1356  gettimeofday (&end_time, NULL);
1357
1358  /* Make the PC point at the start address */
1359  if (exec_bfd)
1360    write_pc (bfd_get_start_address (exec_bfd));
1361
1362  inferior_ptid = null_ptid;	/* No process now */
1363
1364  /* This is necessary because many things were based on the PC at the time
1365     that we attached to the monitor, which is no longer valid now that we
1366     have loaded new code (and just changed the PC).  Another way to do this
1367     might be to call normal_stop, except that the stack may not be valid,
1368     and things would get horribly confused... */
1369
1370  clear_symtab_users ();
1371
1372  if (!nostart)
1373    {
1374      entry = bfd_get_start_address (pbfd);
1375
1376      if (!quiet)
1377	printf_unfiltered ("[Starting %s at 0x%lx]\n", filename, entry);
1378    }
1379
1380  print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
1381			      &end_time);
1382
1383  do_cleanups (old_chain);
1384}
1385
1386static void
1387m32r_stop (void)
1388{
1389  if (remote_debug)
1390    fprintf_unfiltered (gdb_stdlog, "m32r_stop()\n");
1391
1392  send_cmd (SDI_STOP_CPU);
1393
1394  return;
1395}
1396
1397
1398/* Tell whether this target can support a hardware breakpoint.  CNT
1399   is the number of hardware breakpoints already installed.  This
1400   implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro.  */
1401
1402int
1403m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
1404{
1405  return sdi_desc != NULL && cnt < max_access_breaks;
1406}
1407
1408/* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
1409   for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
1410   watchpoint. */
1411
1412int
1413m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
1414{
1415  int i;
1416
1417  if (remote_debug)
1418    fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%08lx,%d,%d)\n",
1419			addr, len, type);
1420
1421  for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1422    {
1423      if (ab_address[i] == 0x00000000)
1424	{
1425	  ab_address[i] = addr;
1426	  ab_size[i] = len;
1427	  ab_type[i] = type;
1428	  return 0;
1429	}
1430    }
1431
1432  error (_("Too many watchpoints"));
1433  return 1;
1434}
1435
1436int
1437m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
1438{
1439  int i;
1440
1441  if (remote_debug)
1442    fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%08lx,%d,%d)\n",
1443			addr, len, type);
1444
1445  for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1446    {
1447      if (ab_address[i] == addr)
1448	{
1449	  ab_address[i] = 0x00000000;
1450	  break;
1451	}
1452    }
1453
1454  return 0;
1455}
1456
1457int
1458m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
1459{
1460  int rc = 0;
1461  if (hit_watchpoint_addr != 0x00000000)
1462    {
1463      *addr_p = hit_watchpoint_addr;
1464      rc = 1;
1465    }
1466  return rc;
1467}
1468
1469int
1470m32r_stopped_by_watchpoint (void)
1471{
1472  CORE_ADDR addr;
1473  return m32r_stopped_data_address (&current_target, &addr);
1474}
1475
1476
1477static void
1478sdireset_command (char *args, int from_tty)
1479{
1480  if (remote_debug)
1481    fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1482
1483  send_cmd (SDI_OPEN);
1484
1485  inferior_ptid = null_ptid;
1486}
1487
1488
1489static void
1490sdistatus_command (char *args, int from_tty)
1491{
1492  unsigned char buf[4096];
1493  int i, c;
1494
1495  if (remote_debug)
1496    fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1497
1498  if (!sdi_desc)
1499    return;
1500
1501  send_cmd (SDI_STATUS);
1502  for (i = 0; i < 4096; i++)
1503    {
1504      c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1505      if (c < 0)
1506	return;
1507      buf[i] = c;
1508      if (c == 0)
1509	break;
1510    }
1511
1512  printf_filtered ("%s", buf);
1513}
1514
1515
1516static void
1517debug_chaos_command (char *args, int from_tty)
1518{
1519  unsigned char buf[3];
1520
1521  buf[0] = SDI_SET_ATTR;
1522  buf[1] = SDI_ATTR_CACHE;
1523  buf[2] = SDI_CACHE_TYPE_CHAOS;
1524  send_data (buf, 3);
1525}
1526
1527
1528static void
1529use_debug_dma_command (char *args, int from_tty)
1530{
1531  unsigned char buf[3];
1532
1533  buf[0] = SDI_SET_ATTR;
1534  buf[1] = SDI_ATTR_MEM_ACCESS;
1535  buf[2] = SDI_MEM_ACCESS_DEBUG_DMA;
1536  send_data (buf, 3);
1537}
1538
1539static void
1540use_mon_code_command (char *args, int from_tty)
1541{
1542  unsigned char buf[3];
1543
1544  buf[0] = SDI_SET_ATTR;
1545  buf[1] = SDI_ATTR_MEM_ACCESS;
1546  buf[2] = SDI_MEM_ACCESS_MON_CODE;
1547  send_data (buf, 3);
1548}
1549
1550
1551static void
1552use_ib_breakpoints_command (char *args, int from_tty)
1553{
1554  use_ib_breakpoints = 1;
1555}
1556
1557static void
1558use_dbt_breakpoints_command (char *args, int from_tty)
1559{
1560  use_ib_breakpoints = 0;
1561}
1562
1563
1564/* Define the target subroutine names */
1565
1566struct target_ops m32r_ops;
1567
1568static void
1569init_m32r_ops (void)
1570{
1571  m32r_ops.to_shortname = "m32rsdi";
1572  m32r_ops.to_longname = "Remote M32R debugging over SDI interface";
1573  m32r_ops.to_doc = "Use an M32R board using SDI debugging protocol.";
1574  m32r_ops.to_open = m32r_open;
1575  m32r_ops.to_close = m32r_close;
1576  m32r_ops.to_detach = m32r_detach;
1577  m32r_ops.to_resume = m32r_resume;
1578  m32r_ops.to_wait = m32r_wait;
1579  m32r_ops.to_fetch_registers = m32r_fetch_register;
1580  m32r_ops.to_store_registers = m32r_store_register;
1581  m32r_ops.to_prepare_to_store = m32r_prepare_to_store;
1582  m32r_ops.deprecated_xfer_memory = m32r_xfer_memory;
1583  m32r_ops.to_files_info = m32r_files_info;
1584  m32r_ops.to_insert_breakpoint = m32r_insert_breakpoint;
1585  m32r_ops.to_remove_breakpoint = m32r_remove_breakpoint;
1586  m32r_ops.to_can_use_hw_breakpoint = m32r_can_use_hw_watchpoint;
1587  m32r_ops.to_insert_watchpoint = m32r_insert_watchpoint;
1588  m32r_ops.to_remove_watchpoint = m32r_remove_watchpoint;
1589  m32r_ops.to_stopped_by_watchpoint = m32r_stopped_by_watchpoint;
1590  m32r_ops.to_stopped_data_address = m32r_stopped_data_address;
1591  m32r_ops.to_kill = m32r_kill;
1592  m32r_ops.to_load = m32r_load;
1593  m32r_ops.to_create_inferior = m32r_create_inferior;
1594  m32r_ops.to_mourn_inferior = m32r_mourn_inferior;
1595  m32r_ops.to_stop = m32r_stop;
1596  m32r_ops.to_stratum = process_stratum;
1597  m32r_ops.to_has_all_memory = 1;
1598  m32r_ops.to_has_memory = 1;
1599  m32r_ops.to_has_stack = 1;
1600  m32r_ops.to_has_registers = 1;
1601  m32r_ops.to_has_execution = 1;
1602  m32r_ops.to_magic = OPS_MAGIC;
1603};
1604
1605
1606extern initialize_file_ftype _initialize_remote_m32r;
1607
1608void
1609_initialize_remote_m32r (void)
1610{
1611  int i;
1612
1613  init_m32r_ops ();
1614
1615  /* Initialize breakpoints. */
1616  for (i = 0; i < MAX_BREAKPOINTS; i++)
1617    bp_address[i] = 0xffffffff;
1618
1619  /* Initialize access breaks. */
1620  for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1621    ab_address[i] = 0x00000000;
1622
1623  add_target (&m32r_ops);
1624
1625  add_com ("sdireset", class_obscure, sdireset_command,
1626	   _("Reset SDI connection."));
1627
1628  add_com ("sdistatus", class_obscure, sdistatus_command,
1629	   _("Show status of SDI connection."));
1630
1631  add_com ("debug_chaos", class_obscure, debug_chaos_command,
1632	   _("Debug M32R/Chaos."));
1633
1634  add_com ("use_debug_dma", class_obscure, use_debug_dma_command,
1635	   _("Use debug DMA mem access."));
1636  add_com ("use_mon_code", class_obscure, use_mon_code_command,
1637	   _("Use mon code mem access."));
1638
1639  add_com ("use_ib_break", class_obscure, use_ib_breakpoints_command,
1640	   _("Set breakpoints by IB break."));
1641  add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
1642	   _("Set breakpoints by dbt."));
1643}
1644