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