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