projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Thu Sep 28 14:32:11 1995 steve chamberlain <sac@slash.cygnus.com>
[deliverable/binutils-gdb.git] / gdb / remote-rdp.c
CommitLineData
dedcc91d
SC		 1/* Remote debugging for the ARM RDP interface.
2 Copyright 1994, 1995 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20
21 */
22
23
24/*
25 Much of this file (in particular the SWI stuff) is based on code by
26 David Taylor (djt1000@uk.ac.cam.hermes).
27
28 I hacked on and simplified it by removing a lot of sexy features he
29 had added, and some of the (unix specific) workarounds he'd done
30 for other GDB problems - which if they still exist should be fixed
31 in GDB, not in a remote-foo thing . I also made it conform more to
32 the doc I have; which may be wrong.
33
34 Steve Chamberlain (sac@cygnus.com).
35 */
36
37
38#include "defs.h"
39#include "inferior.h"
40#include "wait.h"
41#include "value.h"
42#include "callback.h"
43#include "command.h"
44#ifdef ANSI_PROTOTYPES
45#include <stdarg.h>
46#else
47#include <varargs.h>
48#endif
49
50#include <fcntl.h>
51#include "symfile.h"
52#include "remote-utils.h"
53
54extern struct target_ops remote_rdp_ops;
55static serial_t io;
56static host_callback *callback = &default_callback;
57
58struct
59{
60 int step_info;
61 int break_info;
62 int model_info;
63 int target_info;
64 int can_step;
65 char command_line[10];
66 int rdi_level;
67 int rdi_stopped_status;
68} ds;
69
70
71
72/* Definitions for the RDP protocol. */
73
74#define RDP_MOUTHFULL (1<<6)
75#define FPU_COPRO_NUMBER 1
76
77#define RDP_OPEN 0
78#define RDP_OPEN_TYPE_COLD 0
79#define RDP_OPEN_TYPE_WARM 1
80#define RDP_OPEN_TYPE_RETURN_SEX (1<<3)
81
82#define RDP_CLOSE 1
83
84#define RDP_MEM_READ 2
85
86#define RDP_MEM_WRITE 3
87
88#define RDP_CPU_READ 4
89#define RDP_CPU_WRITE 5
90#define RDP_CPU_READWRITE_MODE_CURRENT 255
91#define RDP_CPU_READWRITE_MASK_PC (1<<16)
92#define RDP_CPU_READWRITE_MASK_CPSR (1<<17)
93#define RDP_CPU_READWRITE_MASK_SPSR (1<<18)
94
95#define RDP_COPRO_READ 6
96#define RDP_COPRO_WRITE 7
97#define RDP_FPU_READWRITE_MASK_FPS (1<<8)
98
99#define RDP_SET_BREAK 0xa
100#define RDP_SET_BREAK_TYPE_PC_EQUAL 0
101#define RDP_SET_BREAK_TYPE_GET_HANDLE (0x10)
102
103#define RDP_CLEAR_BREAK 0xb
104
105#define RDP_EXEC 0x10
106#define RDP_EXEC_TYPE_SYNC 0
107
108#define RDP_STEP 0x11
109
110#define RDP_INFO 0x12
111#define RDP_INFO_ABOUT_STEP 2
112#define RDP_INFO_ABOUT_STEP_GT_1 1
113#define RDP_INFO_ABOUT_STEP_TO_JMP 2
114#define RDP_INFO_ABOUT_STEP_1 4
115#define RDP_INFO_ABOUT_TARGET 0
116#define RDP_INFO_ABOUT_BREAK 1
117#define RDP_INFO_ABOUT_BREAK_COMP 1
118#define RDP_INFO_ABOUT_BREAK_RANGE 2
119#define RDP_INFO_ABOUT_BREAK_BYTE_READ 4
120#define RDP_INFO_ABOUT_BREAK_HALFWORD_READ 8
121#define RDP_INFO_ABOUT_BREAK_WORD_READ (1<<4)
122#define RDP_INFO_ABOUT_BREAK_BYTE_WRITE (1<<5)
123#define RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE (1<<6)
124#define RDP_INFO_ABOUT_BREAK_WORD_WRITE (1<<7)
125#define RDP_INFO_ABOUT_BREAK_MASK (1<<8)
126#define RDP_INFO_ABOUT_BREAK_THREAD_BREAK (1<<9)
127#define RDP_INFO_ABOUT_BREAK_THREAD_WATCH (1<<10)
128#define RDP_INFO_ABOUT_BREAK_COND (1<<11)
129
130#define RDP_RESET 0x7f
131
132/* Returns from RDP */
133#define RDP_RES_STOPPED 0x20
134#define RDP_RES_SWI 0x21
135#define RDP_RES_FATAL 0x5e
136#define RDP_RES_VALUE 0x5f
137#define RDP_RES_VALUE_LITTLE_ENDIAN 240
138#define RDP_RES_VALUE_BIG_ENDIAN 241
139#define RDP_RES_RESET 0x7f
140#define RDP_RES_AT_BREAKPOINT 143
141
142#define RDP_OSOpReply 0x13
143#define RDP_OSOpWord 2
144#define RDP_OSOpNothing 0
145
146static int timeout = 2;
147
148static int
149remote_rdp_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
150 char *myaddr,
151 int len,
152 int write,
153 struct target_ops * target));
154
155
156/* Stuff for talking to the serial layer. */
157
158static unsigned char
159get_byte ()
160{
161 int c = SERIAL_READCHAR (io, timeout);
162
163 if (c == SERIAL_TIMEOUT)
164 {
165 if (timeout == 0)
166 return (unsigned char) c;
167
168 error ("Timeout reading from remote_system");
169 }
170
171 if (remote_debug)
172 printf ("[%02x]", c);
173 return c;
174}
175
176/* Note that the target always speaks little-endian to us,
177 even if it's a big endian machine. */
178static unsigned int
179get_word ()
180{
181 unsigned int val = 0;
182 unsigned int c;
183 int n;
184 for (n = 0; n < 4; n++)
185 {
186 c = get_byte ();
187 val |= c << (n * 8);
188 }
189 return val;
190}
191
192static void
193put_byte (val)
194 char val;
195{
196 SERIAL_WRITE (io, &val, 1);
197}
198
199static void
200put_word (val)
201 long val;
202{
203 /* We always send in little endian */
204 unsigned char b[4];
205 b[0] = val;
206 b[1] = val >> 8;
207 b[2] = val >> 16;
208 b[3] = val >> 24;
209
210 SERIAL_WRITE (io, b, 4);
211}
212
213
214
215/* Stuff for talking to the RDP layer. */
216
217
218/* This is a bit more fancy that need be so that it syncs even in nasty cases. */
219
220static void
221rdp_init ()
222{
223 int oloop;
224
225 for (oloop = 0; oloop < 2; oloop++)
226 {
227 int longtry;
228 SERIAL_FLUSH_INPUT (io);
229 for (longtry = 0; longtry < 2; longtry++)
230 {
231 int try;
232 int flush_and_retry = 0;
233
234 for (try = 0; try < 10 && !flush_and_retry; try++)
235 {
236 int restype;
237
238 put_byte (RDP_OPEN);
239 put_byte (RDP_OPEN_TYPE_COLD | RDP_OPEN_TYPE_RETURN_SEX);
240 put_word (0);
241
242 restype = SERIAL_READCHAR (io, 1);
243
244 switch (restype)
245 {
246 case SERIAL_TIMEOUT:
247 flush_and_retry = 1;
248 break;
249 case RDP_RESET:
250 return;
251 default:
252 printf_unfiltered ("Got res return %d\n", restype);
253 break;
254 case RDP_RES_VALUE:
255 {
256 int resval = SERIAL_READCHAR (io, 1);
257
258 switch (resval)
259 {
260 case SERIAL_TIMEOUT:
261 break;
262 case RDP_RES_VALUE_LITTLE_ENDIAN:
263 target_byte_order = LITTLE_ENDIAN;
264 return;
265 case RDP_RES_VALUE_BIG_ENDIAN:
266 target_byte_order = BIG_ENDIAN;
267 return;
268 default:
269 printf_unfiltered ("Trying to sync, got resval %d\n", resval);
270 }
271 }
272 }
273 }
274 }
275 }
276 error ("Couldn't reset the board, try pressing the reset button");
277}
278
279
280#ifdef ANSI_PROTOTYPES
281void
282send_rdp (char *template,...)
283#else
284void
285send_rdp (char *template, va_alist)
286 va_dcl
287#endif
288{
289 char buf[200];
290 char *dst = buf;
291 va_list alist;
292#ifdef ANSI_PROTOTYPES
293 va_start (alist, template);
294#else
295 va_start (alist);
296#endif
297
298 while (*template)
299 {
300 unsigned int val;
301 int *pi;
302 int *pstat;
303 char *pc;
304 int i;
305 switch (*template++)
306 {
307 case 'b':
308 val = va_arg (alist, int);
309 *dst++ = val;
310 break;
311 case 'w':
312 val = va_arg (alist, int);
313 *dst++ = val;
314 *dst++ = val >> 8;
315 *dst++ = val >> 16;
316 *dst++ = val >> 24;
317 break;
318 case 'S':
319 val = get_byte ();
320 if (val != RDP_RES_VALUE)
321 {
322 printf_unfiltered ("got bad res value of %d, %x\n", val, val);
323 }
324 break;
325 case 'V':
326 pstat = va_arg (alist, int *);
327 pi = va_arg (alist, int *);
328
329 *pstat = get_byte ();
330 /* Check the result was zero, if not read the syndrome */
331 if (*pstat)
332 {
333 *pi = get_word ();
334 }
335 break;
336 case 'Z':
337 /* Check the result code, error if not zero */
338 if (get_byte ())
339 error ("Command garbled");
340 break;
341 case 'W':
342 /* Read a word from the target */
343 pi = va_arg (alist, int *);
344 *pi = get_word ();
345 break;
346 case 'P':
347 /* Read in some bytes from the target. */
348 pc = va_arg (alist, char *);
349 val = va_arg (alist, int);
350 for (i = 0; i < val; i++)
351 {
352 pc[i] = get_byte ();
353 }
354 break;
355 case 'p':
356 /* send what's being pointed at */
357 pc = va_arg (alist, char *);
358 val = va_arg (alist, int);
359 dst = buf;
360 SERIAL_WRITE (io, pc, val);
361 break;
362 case '-':
363 /* Send whats in the queue */
364 if (dst != buf)
365 {
366 SERIAL_WRITE (io, buf, dst - buf);
367 dst = buf;
368 }
369 break;
370 case 'B':
371 pi = va_arg (alist, int *);
372 *pi = get_byte ();
373 break;
374 default:
375 abort ();
376 }
377 }
378 va_end (args);
379
380 if (dst != buf)
381 abort ();
382}
383
384
385static int
386rdp_write (memaddr, buf, len)
387 CORE_ADDR memaddr;
388 char *buf;
389 int len;
390{
391 int res;
392 int val;
393
394 send_rdp ("bww-p-SV", RDP_MEM_WRITE, memaddr, len, buf, len, &res, &val);
395
396 if (res)
397 {
398 return val;
399 }
400 return len;
401}
402
403
404static int
405rdp_read (memaddr, buf, len)
406 CORE_ADDR memaddr;
407 char *buf;
408 int len;
409{
410 int res;
411 int val;
412 send_rdp ("bww-S-P-V",
413 RDP_MEM_READ, memaddr, len,
414 buf, len,
415 &res, &val);
416 if (res)
417 {
418 return val;
419 }
420 return len;
421}
422
423static void
424rdp_fetch_one_register (mask, buf)
425 int mask;
426 char *buf;
427{
428 int val;
429 send_rdp ("bbw-SWZ", RDP_CPU_READ, RDP_CPU_READWRITE_MODE_CURRENT, mask, &val);
430 store_signed_integer (buf, 4, val);
431}
432
433static void
434rdp_fetch_one_fpu_register (mask, buf)
435 int mask;
436 char *buf;
437{
438#if 0
439 /* !!! Since the PIE board doesn't work as documented,
440 and it doesn't have FPU hardware anyway and since it
441 slows everything down, I've disabled this. */
442 int val;
443 if (mask == RDP_FPU_READWRITE_MASK_FPS)
444 {
445 /* this guy is only a word */
446 send_rdp ("bbw-SWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, &val);
447 store_signed_integer (buf, 4, val);
448 }
449 else
450 {
451 /* There are 12 bytes long
452 !! fixme about endianness
453 */
454 int dummy; /* I've seen these come back as four words !! */
455 send_rdp ("bbw-SWWWWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, buf + 0, buf + 4, buf + 8, &dummy);
456 }
457#endif
458 memset (buf, 0, MAX_REGISTER_RAW_SIZE);
459}
460
461
462static void
463rdp_store_one_register (mask, buf)
464 int mask;
465 char *buf;
466{
467 int val = extract_unsigned_integer (buf, 4);
468
469 send_rdp ("bbww-SZ",
470 RDP_CPU_WRITE, RDP_CPU_READWRITE_MODE_CURRENT, mask, val);
471}
472
473
474static void
475rdp_store_one_fpu_register (mask, buf)
476 int mask;
477 char *buf;
478{
479#if 0
480 /* See comment in fetch_one_fpu_register */
481 if (mask == RDP_FPU_READWRITE_MASK_FPS)
482 {
483 int val = extract_unsigned_integer (buf, 4);
484 /* this guy is only a word */
485 send_rdp ("bbww-SZ", RDP_COPRO_WRITE,
486 FPU_COPRO_NUMBER,
487 mask, val);
488 }
489 else
490 {
491 /* There are 12 bytes long
492 !! fixme about endianness
493 */
494 int dummy = 0;
495 /* I've seen these come as four words, not the three advertized !! */
496 printf ("Sending mask %x\n", mask);
497 send_rdp ("bbwwwww-SZ",
498 RDP_COPRO_WRITE,
499 FPU_COPRO_NUMBER,
500 mask,
501 *(int *) (buf + 0),
502 *(int *) (buf + 4),
503 *(int *) (buf + 8),
504 0);
505
506 printf ("done mask %x\n", mask);
507 }
508#endif
509}
510
511\f
512/* Convert between GDB requests and the RDP layer. */
513
514static void
515remote_rdp_fetch_register (regno)
516 int regno;
517{
518 if (regno == -1)
519 {
520 for (regno = 0; regno < NUM_REGS; regno++)
521 remote_rdp_fetch_register (regno);
522 }
523 else
524 {
525 char buf[MAX_REGISTER_RAW_SIZE];
526 if (regno < 15)
527 rdp_fetch_one_register (1 << regno, buf);
528 else if (regno == PC_REGNUM)
529 rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
530 else if (regno == PS_REGNUM)
531 rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
532 else if (regno == FPS_REGNUM)
533 rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);
534 else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
535 rdp_fetch_one_fpu_register (1 << (regno - F0_REGNUM), buf);
536 else
537 {
538 printf ("Help me with fetch reg %d\n", regno);
539 }
540 supply_register (regno, buf);
541 }
542}
543
544
545static void
546remote_rdp_store_register (regno)
547 int regno;
548{
549 if (regno == -1)
550 {
551 for (regno = 0; regno < NUM_REGS; regno++)
552 remote_rdp_store_register (regno);
553 }
554 else
555 {
556 char tmp[MAX_REGISTER_RAW_SIZE];
557 read_register_gen (regno, tmp);
558 if (regno < 15)
559 rdp_store_one_register (1 << regno, tmp);
560 else if (regno == PC_REGNUM)
561 rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
562 else if (regno == PS_REGNUM)
563 rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);
564 else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
565 rdp_store_one_fpu_register (1 << (regno - F0_REGNUM), tmp);
566 else
567 {
568 printf ("Help me with reg %d\n", regno);
569 }
570 }
571}
572
573static void
574remote_rdp_kill ()
575{
576 callback->shutdown (callback);
577}
578
579
580static void
581rdp_info ()
582{
583 send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_STEP,
584 &ds.step_info);
585 send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_BREAK,
586 &ds.break_info);
587 send_rdp ("bw-S-WW-Z", RDP_INFO, RDP_INFO_ABOUT_TARGET,
588 &ds.target_info,
589 &ds.model_info);
590
591 ds.can_step = ds.step_info & RDP_INFO_ABOUT_STEP_1;
592
593 ds.rdi_level = (ds.target_info >> 5) & 3;
594}
595
596
597static void
598rdp_execute_start ()
599{
600 /* Start it off, but don't wait for it */
601 send_rdp ("bb-", RDP_EXEC, RDP_EXEC_TYPE_SYNC);
602}
603
604
605
606#define a_byte 1
607#define a_word 2
608#define a_string 3
609
610
611typedef struct
612{
613 CORE_ADDR n;
614 const char *s;
615}
616argsin;
617
618#define ABYTE 1
619#define AWORD 2
620#define ASTRING 3
621#define ADDRLEN 4
622
623#define SWI_WriteC 0x0
624#define SWI_Write0 0x2
625#define SWI_ReadC 0x4
626#define SWI_CLI 0x5
627#define SWI_GetEnv 0x10
628#define SWI_Exit 0x11
629#define SWI_EnterOS 0x16
630
631#define SWI_GetErrno 0x60
632#define SWI_Clock 0x61
633
634#define SWI_Time 0x63
635#define SWI_Remove 0x64
636#define SWI_Rename 0x65
637#define SWI_Open 0x66
638
639#define SWI_Close 0x68
640#define SWI_Write 0x69
641#define SWI_Read 0x6a
642#define SWI_Seek 0x6b
643#define SWI_Flen 0x6c
644
645#define SWI_IsTTY 0x6e
646#define SWI_TmpNam 0x6f
647#define SWI_InstallHandler 0x70
648#define SWI_GenerateError 0x71
649
650
651static int
652exec_swi (swi, args)
653 int swi;
654 argsin *args;
655{
656 int i;
657 char c;
658 switch (swi)
659 {
660 case SWI_WriteC:
661 callback->write_stdout (callback, &c, 1);
662 return 0;
663 case SWI_Write0:
664 for (i = 0; i < args->n; i++)
665 callback->write_stdout (callback, args->s, strlen (args->s));
666 return 0;
667 case SWI_ReadC:
668 callback->read_stdin (callback, &c, 1);
669 args->n = c;
670 return 1;
671 case SWI_CLI:
672 args->n = callback->system (callback, args->s);
673 return 1;
674 case SWI_GetErrno:
675 args->n = callback->get_errno (callback);
676 return 1;
677 case SWI_Time:
678 args->n = callback->time (callback, NULL);
679 return 1;
680 case SWI_Remove:
681 args->n = callback->unlink (callback, args->s);
682 return 1;
683 case SWI_Rename:
684 args->n = callback->rename (callback, args[0].s, args[1].s);
685 return 1;
686 case SWI_Open:
687 i = 0;
688
689#ifdef O_BINARY
690 if (args[1].n & 1)
691 i |= O_BINARY;
692#endif
693 if (args[1].n & 2)
694 i |= O_RDWR;
695
696 if (args[1].n & 4)
697 {
698 i |= O_CREAT;
699 }
700
701 if (args[1].n & 8)
702 i |= O_APPEND;
703
704 args->n = callback->open (callback, args->s, i);
705 return 1;
706
707 case SWI_Close:
708 args->n = callback->close (callback, args->n);
709 return 1;
710
711 case SWI_Write:
712 args->n = callback->write (callback, args[0].n, args[1].s, args[1].n);
713 return 1;
714 case SWI_Read:
715 {
716 char *copy = alloca (args[2].n);
717 int done = callback->read (callback, args[0].n, copy, args[2].n);
718 if (done > 0)
719 remote_rdp_xfer_inferior_memory (args[0].n, copy, done, 1, 0);
720 args->n -= done;
721 return 1;
722 }
723
724 case SWI_Seek:
725 args->n = callback->lseek (callback, args[0].n, args[1].n, 0) >= 0;
726 return 1;
727 case SWI_Flen:
728 {
729 long old = callback->lseek (callback, args->n, 1, 1);
730 args->n = callback->lseek (callback, args->n, 2, 0);
731 callback->lseek (callback, args->n, old, 0);
732 return 1;
733 }
734
735 case SWI_IsTTY:
736 args->n = callback->isatty (callback, args->n);
737 return 1;
738
739 default:
740 return 0;
741 }
742}
743
744
745static void
746handle_swi ()
747{
748 argsin args[3];
749 char *buf;
750 int len;
751 int count = 0;
752
753 int swino = get_word ();
754 int type = get_byte ();
755 while (type != 0)
756 {
757 switch (type & 0x3)
758 {
759 case ABYTE:
760 args[count].n = get_byte ();
761 break;
762
763 case AWORD:
764 args[count].n = get_word ();
765 break;
766
767 case ASTRING:
768 /* If the word is under 32 bytes it will be sent otherwise
769 an address to it is passed. Also: Special case of 255 */
770
771 len = get_byte ();
772 if (len > 32)
773 {
774 if (len == 255)
775 {
776 len = get_word ();
777 }
778 buf = alloca (len);
779 remote_rdp_xfer_inferior_memory (get_word (),
780 buf,
781 len,
782 0,
783 0);
784 }
785 else
786 {
787 int i;
788 buf = alloca (len + 1);
789 for (i = 0; i < len; i++)
790 buf[i] = get_byte ();
791 buf[i] = 0;
792 }
793 args[count].n = len;
794 args[count].s = buf;
795 break;
796
797 default:
798 error ("Unimplented SWI argument");
799 }
800
801 type = type >> 2;
802 count++;
803 }
804
805 if (exec_swi (swino, args))
806 {
807 /* We have two options here reply with either a byte or a word
808 which is stored in args[0].n. There is no harm in replying with
809 a word all the time, so thats what I do! */
810 send_rdp ("bbw-", RDP_OSOpReply, RDP_OSOpWord, args[0].n);
811 }
812 else
813 {
814 send_rdp ("bb-", RDP_OSOpReply, RDP_OSOpNothing);
815 }
816}
817
818static void
819rdp_execute_finish ()
820{
821 int running = 1;
822
823 while (running)
824 {
825 int res;
826 res = SERIAL_READCHAR (io, 1);
827 while (res == SERIAL_TIMEOUT)
828 {
829 QUIT ;
830 printf_filtered ("Waiting for target..\n");
831 res = SERIAL_READCHAR (io, 1);
832 }
833
834 switch (res)
835 {
836 case RDP_RES_SWI:
837 handle_swi ();
838 break;
839 case RDP_RES_VALUE:
840 send_rdp ("B", &ds.rdi_stopped_status);
841 running = 0;
842 break;
843 case RDP_RESET:
844 printf_filtered ("Target reset\n");
845 running = 0;
846 break;
847 default:
848 printf_filtered ("Ignoring %x\n", res);
849 break;
850 }
851 }
852}
853
854
855static void
856rdp_execute ()
857{
858 rdp_execute_start ();
859 rdp_execute_finish ();
860}
861
862static int
863remote_rdp_insert_breakpoint (addr, save)
864 CORE_ADDR addr;
865 char *save;
866{
867 int res;
868 if (ds.rdi_level > 0)
869 {
870 send_rdp ("bwb-SWB",
871 RDP_SET_BREAK,
872 addr,
873 RDP_SET_BREAK_TYPE_PC_EQUAL | RDP_SET_BREAK_TYPE_GET_HANDLE,
874 save,
875 &res);
876 }
877 else
878 {
879 send_rdp ("bwb-SB",
880 RDP_SET_BREAK,
881 addr,
882 RDP_SET_BREAK_TYPE_PC_EQUAL,
883 &res);
884 }
885 return res;
886}
887
888static int
889remote_rdp_remove_breakpoint (addr, save)
890 CORE_ADDR addr;
891 char *save;
892{
893 int res;
894 if (ds.rdi_level > 0)
895 {
896 send_rdp ("b-p-S-B",
897 RDP_CLEAR_BREAK,
898 save, 4,
899 &res);
900 }
901 else
902 {
903 send_rdp ("bw-S-B",
904 RDP_CLEAR_BREAK,
905 addr,
906 &res);
907 }
908 return res;
909}
910
911static void
912rdp_step ()
913{
914 if (ds.can_step && 0)
915 {
916 /* The pie board can't do steps so I can't test this, and
917 the other code will always work. */
918 int status;
919 send_rdp ("bbw-S-B",
920 RDP_STEP, 0, 1,
921 &status);
922 }
923 else
924 {
925 char handle[4];
926 CORE_ADDR pc = read_register (PC_REGNUM);
927 pc = arm_get_next_pc (pc);
928 remote_rdp_insert_breakpoint (pc, &handle);
929 rdp_execute ();
930 remote_rdp_remove_breakpoint (pc, &handle);
931 }
932}
933
934static void
935remote_rdp_open (args, from_tty)
936 char *args;
937 int from_tty;
938{
939 if (!args)
940 error_no_arg ("serial port device name");
941
942 target_preopen (from_tty);
943
944 io = SERIAL_OPEN (args);
945
946 if (!io)
947 perror_with_name (args);
948
949 SERIAL_RAW (io);
950
951 rdp_init ();
952
953 rdp_info ();
954 if (from_tty)
955 {
956 printf_unfiltered ("Remote RDP debugging using %s\n", args);
957 }
958
959 push_target (&remote_rdp_ops);
960
961 callback->init (callback);
962 flush_cached_frames ();
963 registers_changed ();
964 stop_pc = read_pc ();
965 set_current_frame (create_new_frame (read_fp (), stop_pc));
966 select_frame (get_current_frame (), 0);
967 print_stack_frame (selected_frame, -1, 1);
968}
969
970
971
972/* Close out all files and local state before this target loses control. */
973
974static void
975remote_rdp_close (quitting)
976 int quitting;
977{
978 callback->shutdown (callback);
979 SERIAL_CLOSE (io);
980}
981
982/* Terminate the open connection to the remote debugger. */
983
984static void
985remote_rdp_detach (args, from_tty)
986 char *args;
987 int from_tty;
988{
989 pop_target ();
990}
991
992/* Resume execution of the target process. STEP says whether to single-step
993 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
994 to the target, or zero for no signal. */
995
996static void
997remote_rdp_resume (pid, step, siggnal)
998 int pid, step;
999 enum target_signal siggnal;
1000{
1001 if (step)
1002 rdp_step ();
1003 else
1004 rdp_execute ();
1005}
1006
1007/* Wait for inferior process to do something. Return pid of child,
1008 or -1 in case of error; store status through argument pointer STATUS,
1009 just as `wait' would. */
1010
1011static int
1012remote_rdp_wait (pid, status)
1013 int pid;
1014 struct target_waitstatus *status;
1015{
1016 switch (ds.rdi_stopped_status)
1017 {
1018 default:
1019 case RDP_RES_RESET:
1020 case RDP_RES_SWI:
1021 status->kind = TARGET_WAITKIND_EXITED;
1022 status->value.integer = read_register (0);
1023 break;
1024 case RDP_RES_AT_BREAKPOINT:
1025 status->kind = TARGET_WAITKIND_STOPPED;
1026 /* The signal in sigrc is a host signal. That probably
1027 should be fixed. */
1028 status->value.sig = TARGET_SIGNAL_TRAP;
1029 break;
1030#if 0
1031 case rdp_signalled:
1032 status->kind = TARGET_WAITKIND_SIGNALLED;
1033 /* The signal in sigrc is a host signal. That probably
1034 should be fixed. */
1035 status->value.sig = target_signal_from_host (sigrc);
1036 break;
1037#endif
1038 }
1039
1040 return inferior_pid;
1041}
1042
1043/* Get ready to modify the registers array. On machines which store
1044 individual registers, this doesn't need to do anything. On machines
1045 which store all the registers in one fell swoop, this makes sure
1046 that registers contains all the registers from the program being
1047 debugged. */
1048
1049static void
1050remote_rdp_prepare_to_store ()
1051{
1052 /* Do nothing, since we can store individual regs */
1053}
1054
1055static int
1056remote_rdp_xfer_inferior_memory (memaddr, myaddr, len, write, target)
1057 CORE_ADDR memaddr;
1058 char *myaddr;
1059 int len;
1060 int write;
1061 struct target_ops *target; /* ignored */
1062{
1063 /* I infer from D Taylor's code that there's a limit on the amount
1064 we can transfer in one chunk.. */
1065 int done = 0;
1066 while (done < len)
1067 {
1068 int justdone;
1069 int thisbite = len - done;
1070 if (thisbite > RDP_MOUTHFULL)
1071 thisbite = RDP_MOUTHFULL;
1072
1073 QUIT;
1074
1075 if (write)
1076 {
1077 justdone = rdp_write (memaddr + done, myaddr + done, thisbite);
1078 }
1079 else
1080 {
1081 justdone = rdp_read (memaddr + done, myaddr + done, thisbite);
1082 }
1083
1084 done += justdone;
1085
1086 if (justdone != thisbite)
1087 break;
1088 }
1089 return done;
1090}
1091
1092
1093
1094struct yn
1095{
1096 const char *name;
1097 int bit;
1098};
1099static struct yn stepinfo[] =
1100{
1101 {"Step more than one instruction", RDP_INFO_ABOUT_STEP_GT_1},
1102 {"Step to jump", RDP_INFO_ABOUT_STEP_TO_JMP},
1103 {"Step one instruction", RDP_INFO_ABOUT_STEP_1},
1104 {0}
1105};
1106
1107static struct yn breakinfo[] =
1108{
1109 {"comparison breakpoints supported", RDP_INFO_ABOUT_BREAK_COMP},
1110 {"range breakpoints supported", RDP_INFO_ABOUT_BREAK_RANGE},
1111 {"watchpoints for byte reads supported", RDP_INFO_ABOUT_BREAK_BYTE_READ},
1112 {"watchpoints for half-word reads supported", RDP_INFO_ABOUT_BREAK_HALFWORD_READ},
1113 {"watchpoints for word reads supported", RDP_INFO_ABOUT_BREAK_WORD_READ},
1114 {"watchpoints for byte writes supported", RDP_INFO_ABOUT_BREAK_BYTE_WRITE},
1115 {"watchpoints for half-word writes supported", RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE},
1116 {"watchpoints for word writes supported", RDP_INFO_ABOUT_BREAK_WORD_WRITE},
1117 {"mask break/watch-points supported", RDP_INFO_ABOUT_BREAK_MASK},
1118 {"thread-specific breakpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_BREAK},
1119 {"thread-specific watchpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_WATCH},
1120 {"conditional breakpoints supported", RDP_INFO_ABOUT_BREAK_COND},
1121 {0}
1122};
1123
1124
1125static void
1126dump_bits (t, info)
1127 struct yn *t;
1128 int info;
1129{
1130 while (t->name)
1131 {
1132 printf_unfiltered (" %-45s : %s\n", t->name, (info & t->bit) ? "Yes" : "No");
1133 t++;
1134 }
1135}
1136
1137static void
1138remote_rdp_files_info (target)
1139 struct target_ops *target;
1140{
1141 printf_filtered ("Target capabilities:\n");
1142 dump_bits (stepinfo, ds.step_info);
1143 dump_bits (breakinfo, ds.break_info);
1144 printf_unfiltered ("target level RDI %x\n", (ds.target_info >> 5) & 3);
1145}
1146
1147
1148/* Define the target subroutine names */
1149
1150struct target_ops remote_rdp_ops =
1151{
1152 "rdp", /* to_shortname */
1153 /* to_longname */
1154 "Remote Target using the RDProtocol",
1155 /* to_doc */
1156 "Use a remote ARM system which uses the ARM Remote Debugging Protocol",
1157 remote_rdp_open, /* to_open */
1158 remote_rdp_close, /* to_close */
1159 NULL, /* to_attach */
1160 NULL, /* to_detach */
1161 remote_rdp_resume, /* to_resume */
1162 remote_rdp_wait, /* to_wait */
1163 remote_rdp_fetch_register, /* to_fetch_registers */
1164 remote_rdp_store_register, /* to_store_registers */
1165 remote_rdp_prepare_to_store, /* to_prepare_to_store */
1166 remote_rdp_xfer_inferior_memory, /* to_xfer_memory */
1167 remote_rdp_files_info, /* to_files_info */
1168 remote_rdp_insert_breakpoint, /* to_insert_breakpoint */
1169 remote_rdp_remove_breakpoint, /* to_remove_breakpoint */
1170 NULL, /* to_terminal_init */
1171 NULL, /* to_terminal_inferior */
1172 NULL, /* to_terminal_ours_for_output */
1173 NULL, /* to_terminal_ours */
1174 NULL, /* to_terminal_info */
1175 remote_rdp_kill, /* to_kill */
1176 generic_load, /* to_load */
1177 NULL, /* to_lookup_symbol */
1178 NULL, /* to_create_inferior */
1179 generic_mourn_inferior, /* to_mourn_inferior */
1180 0, /* to_can_run */
1181 0, /* to_notice_signals */
1182 0, /* to_thread_alive */
1183 0, /* to_stop */
1184 process_stratum, /* to_stratum */
1185 NULL, /* to_next */
1186 1, /* to_has_all_memory */
1187 1, /* to_has_memory */
1188 1, /* to_has_stack */
1189 1, /* to_has_registers */
1190 1, /* to_has_execution */
1191 NULL, /* sections */
1192 NULL, /* sections_end */
1193 OPS_MAGIC, /* to_magic */
1194};
1195
1196void
1197_initialize_remote_rdp ()
1198{
1199 add_target (&remote_rdp_ops);
1200}
GDB Binutils - Deliverables
This page took 0.075891 seconds and 4 git commands to generate.