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