projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* infrun.c (normal_stop): Don't call
[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
696m32r_wait (ptid_t ptid, struct target_waitstatus *status)
697{
698 static RETSIGTYPE (*prev_sigint) ();
699 unsigned long bp_addr, pc_addr;
e22f895c 700 int ib_breakpoints;
b4b4b794
KI		 701 long i;
702 unsigned char buf[13];
703 unsigned long val;
704 int ret, c;
705
706 if (remote_debug)
707 fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
708
709 status->kind = TARGET_WAITKIND_EXITED;
710 status->value.sig = 0;
711
712 interrupted = 0;
713 prev_sigint = signal (SIGINT, gdb_cntrl_c);
714
715 /* Wait for ready */
716 buf[0] = SDI_WAIT_FOR_READY;
717 if (serial_write (sdi_desc, buf, 1) != 0)
8a3fe4f8 718 error (_("Remote connection closed"));
b4b4b794
KI		 719
720 while (1)
721 {
722 c = serial_readchar (sdi_desc, SDI_TIMEOUT);
723 if (c < 0)
8a3fe4f8 724 error (_("Remote connection closed"));
b4b4b794 725
717eb1cf 726 if (c == '-') /* error */
b4b4b794
KI		 727 {
728 status->kind = TARGET_WAITKIND_STOPPED;
729 status->value.sig = TARGET_SIGNAL_HUP;
730 return inferior_ptid;
731 }
732 else if (c == '+') /* stopped */
733 break;
734
735 if (interrupted)
736 ret = serial_write (sdi_desc, "!", 1); /* packet to interrupt */
737 else
738 ret = serial_write (sdi_desc, ".", 1); /* packet to wait */
739 if (ret != 0)
8a3fe4f8 740 error (_("Remote connection closed"));
b4b4b794
KI		 741 }
742
743 status->kind = TARGET_WAITKIND_STOPPED;
744 if (interrupted)
745 status->value.sig = TARGET_SIGNAL_INT;
746 else
747 status->value.sig = TARGET_SIGNAL_TRAP;
748
749 interrupted = 0;
750 signal (SIGINT, prev_sigint);
751
752 check_mmu_status ();
753
754 /* Recover parallel bit. */
755 if (last_pc_addr != 0xffffffff)
756 {
757 buf[0] = SDI_WRITE_MEMORY;
1cf3db46 758 if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
b4b4b794
KI		 759 store_long_parameter (buf + 1, last_pc_addr);
760 else
761 store_long_parameter (buf + 1, last_pc_addr - 1);
762 store_long_parameter (buf + 5, 1);
763 buf[9] = last_pc_addr_data[0];
764 send_data (buf, 10);
765 last_pc_addr = 0xffffffff;
766 }
767
e22f895c
KI		 768 if (use_ib_breakpoints)
769 ib_breakpoints = max_ib_breakpoints;
770 else
771 ib_breakpoints = 0;
b4b4b794 772
e22f895c
KI		 773 /* Set back pc by 2 if m32r is stopped with dbt. */
774 last_pc_addr = 0xffffffff;
775 send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC);
776 pc_addr = recv_long_data () - 2;
777 for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
778 {
779 if (pc_addr == bp_address[i])
b4b4b794 780 {
e22f895c
KI		 781 send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
782
783 /* If there is a parallel instruction with +2 offset at pc
784 address, we have to take care of it later. */
785 if ((pc_addr & 0x2) != 0)
b4b4b794 786 {
1cf3db46 787 if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
b4b4b794 788 {
e22f895c 789 if ((bp_data[i][2] & 0x80) != 0)
b4b4b794 790 {
e22f895c
KI		 791 last_pc_addr = pc_addr;
792 last_pc_addr_data[0] = bp_data[i][2];
793 last_pc_addr_data[1] = bp_data[i][3];
b4b4b794 794 }
e22f895c
KI		 795 }
796 else
797 {
798 if ((bp_data[i][1] & 0x80) != 0)
b4b4b794 799 {
e22f895c
KI		 800 last_pc_addr = pc_addr;
801 last_pc_addr_data[0] = bp_data[i][1];
802 last_pc_addr_data[1] = bp_data[i][0];
b4b4b794
KI		 803 }
804 }
b4b4b794 805 }
e22f895c 806 break;
b4b4b794 807 }
e22f895c 808 }
b4b4b794 809
e22f895c
KI		 810 /* Remove ib breakpoints. */
811 for (i = 0; i < ib_breakpoints; i++)
812 {
813 if (bp_address[i] != 0xffffffff)
814 send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
815 0x00000000);
816 }
817 /* Remove dbt breakpoints. */
818 for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
819 {
820 bp_addr = bp_address[i];
821 if (bp_addr != 0xffffffff)
b4b4b794 822 {
e22f895c
KI		 823 if (!mmu_on)
824 bp_addr &= 0x7fffffff;
492e5c6b 825 buf[0] = SDI_WRITE_MEMORY;
e22f895c
KI		 826 store_long_parameter (buf + 1, bp_addr & 0xfffffffc);
827 store_long_parameter (buf + 5, 4);
828 buf[9] = bp_data[i][0];
829 buf[10] = bp_data[i][1];
830 buf[11] = bp_data[i][2];
831 buf[12] = bp_data[i][3];
832 send_data (buf, 13);
b4b4b794 833 }
e22f895c 834 }
b4b4b794 835
e22f895c
KI		 836 /* Remove access breaks. */
837 hit_watchpoint_addr = 0;
838 for (i = 0; i < max_access_breaks; i++)
839 {
840 if (ab_address[i] != 0x00000000)
b4b4b794 841 {
e22f895c
KI		 842 buf[0] = SDI_READ_MEMORY;
843 store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
844 store_long_parameter (buf + 5, 4);
845 serial_write (sdi_desc, buf, 9);
846 c = serial_readchar (sdi_desc, SDI_TIMEOUT);
847 if (c != '-' && recv_data (buf, 4) != -1)
b4b4b794 848 {
1cf3db46 849 if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
b4b4b794 850 {
e22f895c
KI		 851 if ((buf[3] & 0x1) == 0x1)
852 hit_watchpoint_addr = ab_address[i];
853 }
854 else
855 {
856 if ((buf[0] & 0x1) == 0x1)
857 hit_watchpoint_addr = ab_address[i];
b4b4b794 858 }
b4b4b794 859 }
b4b4b794 860
e22f895c
KI		 861 send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
862 0x00000000);
863 }
b4b4b794 864 }
e22f895c
KI		 865
866 if (remote_debug)
867 fprintf_unfiltered (gdb_stdlog, "pc => 0x%lx\n", pc_addr);
b4b4b794
KI		 868
869 return inferior_ptid;
870}
871
872/* Terminate the open connection to the remote debugger.
873 Use this when you want to detach and do something else
874 with your gdb. */
875static void
136d6dae 876m32r_detach (struct target_ops *ops, char *args, int from_tty)
b4b4b794
KI		 877{
878 if (remote_debug)
879 fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
880
881 m32r_resume (inferior_ptid, 0, 0);
882
883 /* calls m32r_close to do the real work */
884 pop_target ();
885 if (from_tty)
886 fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
887 target_shortname);
888}
889
890/* Return the id of register number REGNO. */
891
892static int
893get_reg_id (int regno)
894{
895 switch (regno)
896 {
897 case 20:
898 return SDI_REG_BBPC;
899 case 21:
900 return SDI_REG_BPC;
901 case 22:
902 return SDI_REG_ACCL;
903 case 23:
904 return SDI_REG_ACCH;
905 case 24:
906 return SDI_REG_EVB;
907 }
908
909 return regno;
910}
911
912/* Read the remote registers into the block REGS. */
913
56be3814 914static void m32r_fetch_register (struct regcache *, int);
b4b4b794
KI		 915
916static void
56be3814 917m32r_fetch_registers (struct regcache *regcache)
b4b4b794
KI		 918{
919 int regno;
920
40a6adc1
MD		 921 for (regno = 0;
922 regno < gdbarch_num_regs (get_regcache_arch (regcache));
923 regno++)
56be3814 924 m32r_fetch_register (regcache, regno);
b4b4b794
KI		 925}
926
927/* Fetch register REGNO, or all registers if REGNO is -1.
928 Returns errno value. */
929static void
56be3814 930m32r_fetch_register (struct regcache *regcache, int regno)
b4b4b794
KI		 931{
932 unsigned long val, val2, regid;
b4b4b794
KI		 933
934 if (regno == -1)
56be3814 935 m32r_fetch_registers (regcache);
b4b4b794
KI		 936 else
937 {
938 char buffer[MAX_REGISTER_SIZE];
939
940 regid = get_reg_id (regno);
e22f895c
KI		 941 send_one_arg_cmd (SDI_READ_CPU_REG, regid);
942 val = recv_long_data ();
b4b4b794
KI		 943
944 if (regid == SDI_REG_PSW)
945 {
e22f895c
KI		 946 send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
947 val2 = recv_long_data ();
3e41d55f 948 val = ((0x00cf & val2) << 8) | ((0xcf00 & val) >> 8);
b4b4b794
KI		 949 }
950
951 if (remote_debug)
952 fprintf_unfiltered (gdb_stdlog, "m32r_fetch_register(%d,0x%08lx)\n",
953 regno, val);
954
955 /* We got the number the register holds, but gdb expects to see a
956 value in the target byte ordering. */
957 store_unsigned_integer (buffer, 4, val);
56be3814 958 regcache_raw_supply (regcache, regno, buffer);
b4b4b794
KI		 959 }
960 return;
961}
962
963/* Store the remote registers from the contents of the block REGS. */
964
56be3814 965static void m32r_store_register (struct regcache *, int);
b4b4b794
KI		 966
967static void
56be3814 968m32r_store_registers (struct regcache *regcache)
b4b4b794
KI		 969{
970 int regno;
971
40a6adc1
MD		 972 for (regno = 0;
973 regno < gdbarch_num_regs (get_regcache_arch (regcache));
974 regno++)
56be3814 975 m32r_store_register (regcache, regno);
b4b4b794
KI		 976
977 registers_changed ();
978}
979
980/* Store register REGNO, or all if REGNO == 0.
981 Return errno value. */
982static void
56be3814 983m32r_store_register (struct regcache *regcache, int regno)
b4b4b794
KI		 984{
985 int regid;
986 ULONGEST regval, tmp;
b4b4b794
KI		 987
988 if (regno == -1)
56be3814 989 m32r_store_registers (regcache);
b4b4b794
KI		 990 else
991 {
56be3814 992 regcache_cooked_read_unsigned (regcache, regno, &regval);
b4b4b794
KI		 993 regid = get_reg_id (regno);
994
995 if (regid == SDI_REG_PSW)
996 {
997 unsigned long psw, bbpsw;
998
e22f895c
KI		 999 send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_PSW);
1000 psw = recv_long_data ();
b4b4b794 1001
e22f895c
KI		 1002 send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
1003 bbpsw = recv_long_data ();
b4b4b794 1004
3e41d55f 1005 tmp = (0x00cf & psw) | ((0x00cf & regval) << 8);
e22f895c 1006 send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PSW, tmp);
b4b4b794 1007
3e41d55f 1008 tmp = (0x0030 & bbpsw) | ((0xcf00 & regval) >> 8);
e22f895c 1009 send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BBPSW, tmp);
b4b4b794
KI		 1010 }
1011 else
1012 {
e22f895c 1013 send_two_arg_cmd (SDI_WRITE_CPU_REG, regid, regval);
b4b4b794
KI		 1014 }
1015
1016 if (remote_debug)
1017 fprintf_unfiltered (gdb_stdlog, "m32r_store_register(%d,0x%08lu)\n",
1018 regno, (unsigned long) regval);
1019 }
1020}
1021
1022/* Get ready to modify the registers array. On machines which store
1023 individual registers, this doesn't need to do anything. On machines
1024 which store all the registers in one fell swoop, this makes sure
1025 that registers contains all the registers from the program being
1026 debugged. */
1027
1028static void
316f2060 1029m32r_prepare_to_store (struct regcache *regcache)
b4b4b794
KI		 1030{
1031 /* Do nothing, since we can store individual regs */
1032 if (remote_debug)
1033 fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
1034}
1035
1036static void
1037m32r_files_info (struct target_ops *target)
1038{
1039 char *file = "nothing";
1040
1041 if (exec_bfd)
1042 {
1043 file = bfd_get_filename (exec_bfd);
1044 printf_filtered ("\tAttached to %s running program %s\n",
1045 chip_name, file);
1046 }
1047}
1048
1049/* Read/Write memory. */
1050static int
16ac4ab5 1051m32r_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
b4b4b794
KI		 1052 int write,
1053 struct mem_attrib *attrib, struct target_ops *target)
1054{
1055 unsigned long taddr;
1056 unsigned char buf[0x2000];
1057 int ret, c;
1058
1059 taddr = memaddr;
1060
1061 if (!mmu_on)
1062 {
1063 if ((taddr & 0xa0000000) == 0x80000000)
1064 taddr &= 0x7fffffff;
1065 }
1066
1067 if (remote_debug)
1068 {
1069 if (write)
ec20a626
UW		 1070 fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
1071 paddr (memaddr), len);
b4b4b794 1072 else
ec20a626
UW		 1073 fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
1074 paddr (memaddr), len);
b4b4b794
KI		 1075 }
1076
1077 if (write)
1078 {
1079 buf[0] = SDI_WRITE_MEMORY;
1080 store_long_parameter (buf + 1, taddr);
1081 store_long_parameter (buf + 5, len);
1082 if (len < 0x1000)
1083 {
1084 memcpy (buf + 9, myaddr, len);
1085 ret = send_data (buf, len + 9) - 9;
1086 }
1087 else
1088 {
1089 if (serial_write (sdi_desc, buf, 9) != 0)
1090 {
1091 if (remote_debug)
1092 fprintf_unfiltered (gdb_stdlog,
1093 "m32r_xfer_memory() failed\n");
1094 return 0;
1095 }
1096 ret = send_data (myaddr, len);
1097 }
1098 }
1099 else
1100 {
1101 buf[0] = SDI_READ_MEMORY;
1102 store_long_parameter (buf + 1, taddr);
1103 store_long_parameter (buf + 5, len);
1104 if (serial_write (sdi_desc, buf, 9) != 0)
1105 {
1106 if (remote_debug)
1107 fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1108 return 0;
1109 }
1110
1111 c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1112 if (c < 0 || c == '-')
1113 {
1114 if (remote_debug)
1115 fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1116 return 0;
1117 }
1118
1119 ret = recv_data (myaddr, len);
1120 }
1121
1122 if (ret <= 0)
1123 {
1124 if (remote_debug)
1125 fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() fails\n");
1126 return 0;
1127 }
1128
1129 return ret;
1130}
1131
1132static void
1133m32r_kill (void)
1134{
1135 if (remote_debug)
1136 fprintf_unfiltered (gdb_stdlog, "m32r_kill()\n");
1137
1138 inferior_ptid = null_ptid;
e5ef4d75 1139 delete_thread_silent (remote_m32r_ptid);
b4b4b794
KI		 1140
1141 return;
1142}
1143
1144/* Clean up when a program exits.
1145
1146 The program actually lives on in the remote processor's RAM, and may be
1147 run again without a download. Don't leave it full of breakpoint
1148 instructions. */
1149
1150static void
136d6dae 1151m32r_mourn_inferior (struct target_ops *ops)
b4b4b794
KI		 1152{
1153 if (remote_debug)
1154 fprintf_unfiltered (gdb_stdlog, "m32r_mourn_inferior()\n");
1155
1156 remove_breakpoints ();
1157 generic_mourn_inferior ();
1158}
1159
1160static int
8181d85f 1161m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
b4b4b794 1162{
8181d85f 1163 CORE_ADDR addr = bp_tgt->placed_address;
b4b4b794
KI		 1164 int ib_breakpoints;
1165 unsigned char buf[13];
1166 int i, c;
1167
1168 if (remote_debug)
ec20a626
UW		 1169 fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",
1170 paddr (addr));
b4b4b794
KI		 1171
1172 if (use_ib_breakpoints)
1173 ib_breakpoints = max_ib_breakpoints;
1174 else
1175 ib_breakpoints = 0;
1176
1177 for (i = 0; i < MAX_BREAKPOINTS; i++)
1178 {
1179 if (bp_address[i] == 0xffffffff)
1180 {
1181 bp_address[i] = addr;
1182 if (i >= ib_breakpoints)
1183 {
1184 buf[0] = SDI_READ_MEMORY;
1185 if (mmu_on)
1186 store_long_parameter (buf + 1, addr & 0xfffffffc);
1187 else
1188 store_long_parameter (buf + 1, addr & 0x7ffffffc);
1189 store_long_parameter (buf + 5, 4);
1190 serial_write (sdi_desc, buf, 9);
1191 c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1192 if (c != '-')
1193 recv_data (bp_data[i], 4);
1194 }
1195 return 0;
1196 }
1197 }
1198
8a3fe4f8 1199 error (_("Too many breakpoints"));
b4b4b794
KI		 1200 return 1;
1201}
1202
1203static int
8181d85f 1204m32r_remove_breakpoint (struct bp_target_info *bp_tgt)
b4b4b794 1205{
8181d85f 1206 CORE_ADDR addr = bp_tgt->placed_address;
b4b4b794
KI		 1207 int i;
1208
1209 if (remote_debug)
ec20a626
UW		 1210 fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",
1211 paddr (addr));
b4b4b794
KI		 1212
1213 for (i = 0; i < MAX_BREAKPOINTS; i++)
1214 {
1215 if (bp_address[i] == addr)
1216 {
1217 bp_address[i] = 0xffffffff;
1218 break;
1219 }
1220 }
1221
1222 return 0;
1223}
1224
1225static void
1226m32r_load (char *args, int from_tty)
1227{
1228 struct cleanup *old_chain;
1229 asection *section;
1230 bfd *pbfd;
1231 bfd_vma entry;
1232 char *filename;
1233 int quiet;
1234 int nostart;
2b71414d 1235 struct timeval start_time, end_time;
b4b4b794
KI		 1236 unsigned long data_count; /* Number of bytes transferred to memory */
1237 int ret;
1238 static RETSIGTYPE (*prev_sigint) ();
1239
1240 /* for direct tcp connections, we can do a fast binary download */
1241 quiet = 0;
1242 nostart = 0;
1243 filename = NULL;
1244
1245 while (*args != '\000')
1246 {
1247 char *arg;
1248
1249 while (isspace (*args))
1250 args++;
1251
1252 arg = args;
1253
1254 while ((*args != '\000') && !isspace (*args))
1255 args++;
1256
1257 if (*args != '\000')
1258 *args++ = '\000';
1259
1260 if (*arg != '-')
1261 filename = arg;
1262 else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
1263 quiet = 1;
1264 else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
1265 nostart = 1;
1266 else
8a3fe4f8 1267 error (_("Unknown option `%s'"), arg);
b4b4b794
KI		 1268 }
1269
1270 if (!filename)
1271 filename = get_exec_file (1);
1272
1273 pbfd = bfd_openr (filename, gnutarget);
1274 if (pbfd == NULL)
1275 {
1276 perror_with_name (filename);
1277 return;
1278 }
1279 old_chain = make_cleanup_bfd_close (pbfd);
1280
1281 if (!bfd_check_format (pbfd, bfd_object))
8a3fe4f8 1282 error (_("\"%s\" is not an object file: %s"), filename,
b4b4b794
KI		 1283 bfd_errmsg (bfd_get_error ()));
1284
2b71414d 1285 gettimeofday (&start_time, NULL);
b4b4b794
KI		 1286 data_count = 0;
1287
1288 interrupted = 0;
1289 prev_sigint = signal (SIGINT, gdb_cntrl_c);
1290
1291 for (section = pbfd->sections; section; section = section->next)
1292 {
1293 if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
1294 {
1295 bfd_vma section_address;
1296 bfd_size_type section_size;
1297 file_ptr fptr;
1298 int n;
1299
1300 section_address = bfd_section_lma (pbfd, section);
2c500098 1301 section_size = bfd_get_section_size (section);
b4b4b794
KI		 1302
1303 if (!mmu_on)
1304 {
1305 if ((section_address & 0xa0000000) == 0x80000000)
1306 section_address &= 0x7fffffff;
1307 }
1308
1309 if (!quiet)
1310 printf_filtered ("[Loading section %s at 0x%lx (%d bytes)]\n",
1311 bfd_get_section_name (pbfd, section),
ec20a626
UW		 1312 (unsigned long) section_address,
1313 (int) section_size);
b4b4b794
KI		 1314
1315 fptr = 0;
1316
1317 data_count += section_size;
1318
1319 n = 0;
1320 while (section_size > 0)
1321 {
1322 char unsigned buf[0x1000 + 9];
1323 int count;
1324
1325 count = min (section_size, 0x1000);
1326
1327 buf[0] = SDI_WRITE_MEMORY;
1328 store_long_parameter (buf + 1, section_address);
1329 store_long_parameter (buf + 5, count);
1330
1331 bfd_get_section_contents (pbfd, section, buf + 9, fptr, count);
1332 if (send_data (buf, count + 9) <= 0)
8a3fe4f8 1333 error (_("Error while downloading %s section."),
b4b4b794
KI		 1334 bfd_get_section_name (pbfd, section));
1335
1336 if (!quiet)
1337 {
1338 printf_unfiltered (".");
1339 if (n++ > 60)
1340 {
1341 printf_unfiltered ("\n");
1342 n = 0;
1343 }
1344 gdb_flush (gdb_stdout);
1345 }
1346
1347 section_address += count;
1348 fptr += count;
1349 section_size -= count;
1350
1351 if (interrupted)
1352 break;
1353 }
1354
1355 if (!quiet && !interrupted)
1356 {
1357 printf_unfiltered ("done.\n");
1358 gdb_flush (gdb_stdout);
1359 }
1360 }
1361
1362 if (interrupted)
1363 {
1364 printf_unfiltered ("Interrupted.\n");
1365 break;
1366 }
1367 }
1368
1369 interrupted = 0;
1370 signal (SIGINT, prev_sigint);
1371
2b71414d 1372 gettimeofday (&end_time, NULL);
b4b4b794
KI		 1373
1374 /* Make the PC point at the start address */
1375 if (exec_bfd)
1376 write_pc (bfd_get_start_address (exec_bfd));
1377
1378 inferior_ptid = null_ptid; /* No process now */
e5ef4d75 1379 delete_thread_silent (remote_m32r_ptid);
b4b4b794
KI		 1380
1381 /* This is necessary because many things were based on the PC at the time
1382 that we attached to the monitor, which is no longer valid now that we
1383 have loaded new code (and just changed the PC). Another way to do this
1384 might be to call normal_stop, except that the stack may not be valid,
1385 and things would get horribly confused... */
1386
1387 clear_symtab_users ();
1388
1389 if (!nostart)
1390 {
1391 entry = bfd_get_start_address (pbfd);
1392
1393 if (!quiet)
ec20a626
UW		 1394 printf_unfiltered ("[Starting %s at 0x%lx]\n", filename,
1395 (unsigned long) entry);
b4b4b794
KI		 1396 }
1397
2b71414d
DJ		 1398 print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
1399 &end_time);
b4b4b794
KI		 1400
1401 do_cleanups (old_chain);
1402}
1403
1404static void
f9c72d52 1405m32r_stop (ptid_t ptid)
b4b4b794 1406{
b4b4b794
KI		 1407 if (remote_debug)
1408 fprintf_unfiltered (gdb_stdlog, "m32r_stop()\n");
1409
e22f895c 1410 send_cmd (SDI_STOP_CPU);
b4b4b794
KI		 1411
1412 return;
1413}
1414
1415
37814c18
KI		 1416/* Tell whether this target can support a hardware breakpoint. CNT
1417 is the number of hardware breakpoints already installed. This
1418 implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro. */
b4b4b794
KI		 1419
1420int
37814c18 1421m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
b4b4b794 1422{
37814c18 1423 return sdi_desc != NULL && cnt < max_access_breaks;
b4b4b794
KI		 1424}
1425
1426/* Set a data watchpoint. ADDR and LEN should be obvious. TYPE is 0
1427 for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
1428 watchpoint. */
1429
1430int
37814c18 1431m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
b4b4b794
KI		 1432{
1433 int i;
1434
1435 if (remote_debug)
ec20a626
UW		 1436 fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
1437 paddr (addr), len, type);
b4b4b794
KI		 1438
1439 for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1440 {
1441 if (ab_address[i] == 0x00000000)
1442 {
1443 ab_address[i] = addr;
1444 ab_size[i] = len;
1445 ab_type[i] = type;
1446 return 0;
1447 }
1448 }
1449
8a3fe4f8 1450 error (_("Too many watchpoints"));
b4b4b794
KI		 1451 return 1;
1452}
1453
1454int
1455m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
1456{
1457 int i;
1458
1459 if (remote_debug)
ec20a626
UW		 1460 fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
1461 paddr (addr), len, type);
b4b4b794
KI		 1462
1463 for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1464 {
1465 if (ab_address[i] == addr)
1466 {
1467 ab_address[i] = 0x00000000;
1468 break;
1469 }
1470 }
1471
1472 return 0;
1473}
1474
4aa7a7f5
JJ		 1475int
1476m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
b4b4b794 1477{
4aa7a7f5
JJ		 1478 int rc = 0;
1479 if (hit_watchpoint_addr != 0x00000000)
1480 {
1481 *addr_p = hit_watchpoint_addr;
1482 rc = 1;
1483 }
1484 return rc;
b4b4b794
KI		 1485}
1486
1487int
1488m32r_stopped_by_watchpoint (void)
1489{
4aa7a7f5
JJ		 1490 CORE_ADDR addr;
1491 return m32r_stopped_data_address (&current_target, &addr);
b4b4b794
KI		 1492}
1493
4d6c6261
PA		 1494/* Check to see if a thread is still alive. */
1495
1496static int
1497m32r_thread_alive (ptid_t ptid)
1498{
1499 if (ptid_equal (ptid, remote_m32r_ptid))
1500 /* The main task is always alive. */
1501 return 1;
1502
1503 return 0;
1504}
1505
1506/* Convert a thread ID to a string. Returns the string in a static
1507 buffer. */
1508
1509static char *
1510m32r_pid_to_str (ptid_t ptid)
1511{
1512 static char buf[64];
1513
1514 if (ptid_equal (remote_m32r_ptid, ptid))
1515 {
1516 xsnprintf (buf, sizeof buf, "Thread <main>");
1517 return buf;
1518 }
1519
1520 return normal_pid_to_str (ptid);
1521}
b4b4b794
KI		 1522
1523static void
1524sdireset_command (char *args, int from_tty)
1525{
b4b4b794
KI		 1526 if (remote_debug)
1527 fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1528
e22f895c 1529 send_cmd (SDI_OPEN);
b4b4b794
KI		 1530
1531 inferior_ptid = null_ptid;
e5ef4d75 1532 delete_thread_silent (remote_m32r_ptid);
b4b4b794
KI		 1533}
1534
1535
1536static void
1537sdistatus_command (char *args, int from_tty)
1538{
1539 unsigned char buf[4096];
1540 int i, c;
1541
1542 if (remote_debug)
1543 fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1544
1545 if (!sdi_desc)
1546 return;
1547
e22f895c 1548 send_cmd (SDI_STATUS);
b4b4b794
KI		 1549 for (i = 0; i < 4096; i++)
1550 {
1551 c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1552 if (c < 0)
717eb1cf 1553 return;
b4b4b794
KI		 1554 buf[i] = c;
1555 if (c == 0)
717eb1cf
AC		 1556 break;
1557 }
b4b4b794
KI		 1558
1559 printf_filtered ("%s", buf);
1560}
1561
1562
1563static void
1564debug_chaos_command (char *args, int from_tty)
1565{
1566 unsigned char buf[3];
1567
1568 buf[0] = SDI_SET_ATTR;
1569 buf[1] = SDI_ATTR_CACHE;
1570 buf[2] = SDI_CACHE_TYPE_CHAOS;
1571 send_data (buf, 3);
1572}
1573
1574
1575static void
1576use_debug_dma_command (char *args, int from_tty)
1577{
1578 unsigned char buf[3];
1579
1580 buf[0] = SDI_SET_ATTR;
1581 buf[1] = SDI_ATTR_MEM_ACCESS;
1582 buf[2] = SDI_MEM_ACCESS_DEBUG_DMA;
1583 send_data (buf, 3);
1584}
1585
1586static void
1587use_mon_code_command (char *args, int from_tty)
1588{
1589 unsigned char buf[3];
1590
1591 buf[0] = SDI_SET_ATTR;
1592 buf[1] = SDI_ATTR_MEM_ACCESS;
1593 buf[2] = SDI_MEM_ACCESS_MON_CODE;
1594 send_data (buf, 3);
1595}
1596
1597
1598static void
1599use_ib_breakpoints_command (char *args, int from_tty)
1600{
1601 use_ib_breakpoints = 1;
1602}
1603
1604static void
1605use_dbt_breakpoints_command (char *args, int from_tty)
1606{
1607 use_ib_breakpoints = 0;
1608}
1609
1610
1611/* Define the target subroutine names */
1612
1613struct target_ops m32r_ops;
1614
1615static void
1616init_m32r_ops (void)
1617{
1618 m32r_ops.to_shortname = "m32rsdi";
1619 m32r_ops.to_longname = "Remote M32R debugging over SDI interface";
1620 m32r_ops.to_doc = "Use an M32R board using SDI debugging protocol.";
1621 m32r_ops.to_open = m32r_open;
1622 m32r_ops.to_close = m32r_close;
1623 m32r_ops.to_detach = m32r_detach;
1624 m32r_ops.to_resume = m32r_resume;
1625 m32r_ops.to_wait = m32r_wait;
1626 m32r_ops.to_fetch_registers = m32r_fetch_register;
1627 m32r_ops.to_store_registers = m32r_store_register;
1628 m32r_ops.to_prepare_to_store = m32r_prepare_to_store;
c8e73a31 1629 m32r_ops.deprecated_xfer_memory = m32r_xfer_memory;
b4b4b794
KI		 1630 m32r_ops.to_files_info = m32r_files_info;
1631 m32r_ops.to_insert_breakpoint = m32r_insert_breakpoint;
1632 m32r_ops.to_remove_breakpoint = m32r_remove_breakpoint;
37814c18
KI		 1633 m32r_ops.to_can_use_hw_breakpoint = m32r_can_use_hw_watchpoint;
1634 m32r_ops.to_insert_watchpoint = m32r_insert_watchpoint;
1635 m32r_ops.to_remove_watchpoint = m32r_remove_watchpoint;
1636 m32r_ops.to_stopped_by_watchpoint = m32r_stopped_by_watchpoint;
1637 m32r_ops.to_stopped_data_address = m32r_stopped_data_address;
b4b4b794
KI		 1638 m32r_ops.to_kill = m32r_kill;
1639 m32r_ops.to_load = m32r_load;
1640 m32r_ops.to_create_inferior = m32r_create_inferior;
1641 m32r_ops.to_mourn_inferior = m32r_mourn_inferior;
1642 m32r_ops.to_stop = m32r_stop;
49d03eab 1643 m32r_ops.to_log_command = serial_log_command;
4d6c6261
PA		 1644 m32r_ops.to_thread_alive = m32r_thread_alive;
1645 m32r_ops.to_pid_to_str = m32r_pid_to_str;
b4b4b794
KI		 1646 m32r_ops.to_stratum = process_stratum;
1647 m32r_ops.to_has_all_memory = 1;
1648 m32r_ops.to_has_memory = 1;
1649 m32r_ops.to_has_stack = 1;
1650 m32r_ops.to_has_registers = 1;
1651 m32r_ops.to_has_execution = 1;
1652 m32r_ops.to_magic = OPS_MAGIC;
1653};
1654
1655
1656extern initialize_file_ftype _initialize_remote_m32r;
1657
1658void
1659_initialize_remote_m32r (void)
1660{
1661 int i;
1662
1663 init_m32r_ops ();
1664
1665 /* Initialize breakpoints. */
1666 for (i = 0; i < MAX_BREAKPOINTS; i++)
1667 bp_address[i] = 0xffffffff;
1668
1669 /* Initialize access breaks. */
1670 for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1671 ab_address[i] = 0x00000000;
1672
1673 add_target (&m32r_ops);
1674
1675 add_com ("sdireset", class_obscure, sdireset_command,
1bedd215 1676 _("Reset SDI connection."));
b4b4b794
KI		 1677
1678 add_com ("sdistatus", class_obscure, sdistatus_command,
1bedd215 1679 _("Show status of SDI connection."));
b4b4b794
KI		 1680
1681 add_com ("debug_chaos", class_obscure, debug_chaos_command,
1bedd215 1682 _("Debug M32R/Chaos."));
b4b4b794
KI		 1683
1684 add_com ("use_debug_dma", class_obscure, use_debug_dma_command,
1bedd215 1685 _("Use debug DMA mem access."));
b4b4b794 1686 add_com ("use_mon_code", class_obscure, use_mon_code_command,
1bedd215 1687 _("Use mon code mem access."));
b4b4b794
KI		 1688
1689 add_com ("use_ib_break", class_obscure, use_ib_breakpoints_command,
1bedd215 1690 _("Set breakpoints by IB break."));
b4b4b794 1691 add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
1bedd215 1692 _("Set breakpoints by dbt."));
e5ef4d75
PA		 1693
1694 /* Yes, 42000 is arbitrary. The only sense out of it, is that it
1695 isn't 0. */
1696 remote_m32r_ptid = ptid_build (42000, 0, 42000);
b4b4b794 1697}
GDB Binutils - Deliverables
This page took 0.505557 seconds and 4 git commands to generate.