OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [remote-utils.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Generic support for remote debugging interfaces.
2
 
3
   Copyright 1993, 1994, 1998 Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
/*  This file actually contains two distinct logical "packages".  They
23
   are packaged together in this one file because they are typically
24
   used together.
25
 
26
   The first package is an addition to the serial package.  The
27
   addition provides reading and writing with debugging output and
28
   timeouts based on user settable variables.  These routines are
29
   intended to support serial port based remote backends.  These
30
   functions are prefixed with sr_.
31
 
32
   The second package is a collection of more or less generic
33
   functions for use by remote backends.  They support user settable
34
   variables for debugging, retries, and the like.
35
 
36
   Todo:
37
 
38
   * a pass through mode a la kermit or telnet.
39
   * autobaud.
40
   * ask remote to change his baud rate.
41
 */
42
 
43
#include <ctype.h>
44
 
45
#include "defs.h"
46
#include "gdb_string.h"
47
#include "gdbcmd.h"
48
#include "target.h"
49
#include "serial.h"
50
#include "gdbcore.h"            /* for exec_bfd */
51
#include "inferior.h"           /* for generic_mourn_inferior */
52
#include "remote-utils.h"
53
 
54
 
55
void _initialize_sr_support PARAMS ((void));
56
 
57
struct _sr_settings sr_settings =
58
{
59
  4,                            /* timeout:
60
                                   remote-hms.c had 2
61
                                   remote-bug.c had "with a timeout of 2, we time out waiting for
62
                                   the prompt after an s-record dump."
63
 
64
                                   remote.c had (2): This was 5 seconds, which is a long time to
65
                                   sit and wait. Unless this is going though some terminal server
66
                                   or multiplexer or other form of hairy serial connection, I
67
                                   would think 2 seconds would be plenty.
68
                                 */
69
 
70
  10,                           /* retries */
71
  NULL,                         /* device */
72
  NULL,                         /* descriptor */
73
};
74
 
75
struct gr_settings *gr_settings = NULL;
76
 
77
static void usage PARAMS ((char *, char *));
78
static void sr_com PARAMS ((char *, int));
79
 
80
static void
81
usage (proto, junk)
82
     char *proto;
83
     char *junk;
84
{
85
  if (junk != NULL)
86
    fprintf_unfiltered (gdb_stderr, "Unrecognized arguments: `%s'.\n", junk);
87
 
88
  error ("Usage: target %s [DEVICE [SPEED [DEBUG]]]\n\
89
where DEVICE is the name of a device or HOST:PORT", proto, proto);
90
 
91
  return;
92
}
93
 
94
#define CHECKDONE(p, q) \
95
{ \
96
  if (q == p) \
97
    { \
98
      if (*p == '\0') \
99
        return; \
100
      else \
101
        usage(proto, p); \
102
    } \
103
}
104
 
105
void
106
sr_scan_args (proto, args)
107
     char *proto;
108
     char *args;
109
{
110
  int n;
111
  char *p, *q;
112
 
113
  /* if no args, then nothing to do. */
114
  if (args == NULL || *args == '\0')
115
    return;
116
 
117
  /* scan off white space.  */
118
  for (p = args; isspace (*p); ++p);;
119
 
120
  /* find end of device name.  */
121
  for (q = p; *q != '\0' && !isspace (*q); ++q);;
122
 
123
  /* check for missing or empty device name.  */
124
  CHECKDONE (p, q);
125
  sr_set_device (savestring (p, q - p));
126
 
127
  /* look for baud rate.  */
128
  n = strtol (q, &p, 10);
129
 
130
  /* check for missing or empty baud rate.  */
131
  CHECKDONE (p, q);
132
  baud_rate = n;
133
 
134
  /* look for debug value.  */
135
  n = strtol (p, &q, 10);
136
 
137
  /* check for missing or empty debug value.  */
138
  CHECKDONE (p, q);
139
  sr_set_debug (n);
140
 
141
  /* scan off remaining white space.  */
142
  for (p = q; isspace (*p); ++p);;
143
 
144
  /* if not end of string, then there's unrecognized junk. */
145
  if (*p != '\0')
146
    usage (proto, p);
147
 
148
  return;
149
}
150
 
151
void
152
gr_generic_checkin ()
153
{
154
  sr_write_cr ("");
155
  gr_expect_prompt ();
156
}
157
 
158
void
159
gr_open (args, from_tty, gr)
160
     char *args;
161
     int from_tty;
162
     struct gr_settings *gr;
163
{
164
  target_preopen (from_tty);
165
  sr_scan_args (gr->ops->to_shortname, args);
166
  unpush_target (gr->ops);
167
 
168
  gr_settings = gr;
169
 
170
  gr_set_dcache (dcache_init (gr->readfunc, gr->writefunc));
171
 
172
  if (sr_get_desc () != NULL)
173
    gr_close (0);
174
 
175
  /* If no args are specified, then we use the device specified by a
176
     previous command or "set remotedevice".  But if there is no
177
     device, better stop now, not dump core.  */
178
 
179
  if (sr_get_device () == NULL)
180
    usage (gr->ops->to_shortname, NULL);
181
 
182
  sr_set_desc (SERIAL_OPEN (sr_get_device ()));
183
  if (!sr_get_desc ())
184
    perror_with_name ((char *) sr_get_device ());
185
 
186
  if (baud_rate != -1)
187
    {
188
      if (SERIAL_SETBAUDRATE (sr_get_desc (), baud_rate) != 0)
189
        {
190
          SERIAL_CLOSE (sr_get_desc ());
191
          perror_with_name (sr_get_device ());
192
        }
193
    }
194
 
195
  SERIAL_RAW (sr_get_desc ());
196
 
197
  /* If there is something sitting in the buffer we might take it as a
198
     response to a command, which would be bad.  */
199
  SERIAL_FLUSH_INPUT (sr_get_desc ());
200
 
201
  /* default retries */
202
  if (sr_get_retries () == 0)
203
    sr_set_retries (1);
204
 
205
  /* default clear breakpoint function */
206
  if (gr_settings->clear_all_breakpoints == NULL)
207
    gr_settings->clear_all_breakpoints = remove_breakpoints;
208
 
209
  if (from_tty)
210
    {
211
      printf_filtered ("Remote debugging using `%s'", sr_get_device ());
212
      if (baud_rate != -1)
213
        printf_filtered (" at baud rate of %d",
214
                         baud_rate);
215
      printf_filtered ("\n");
216
    }
217
 
218
  push_target (gr->ops);
219
  gr_checkin ();
220
  gr_clear_all_breakpoints ();
221
  return;
222
}
223
 
224
/* Read a character from the remote system masking it down to 7 bits
225
   and doing all the fancy timeout stuff.  */
226
 
227
int
228
sr_readchar ()
229
{
230
  int buf;
231
 
232
  buf = SERIAL_READCHAR (sr_get_desc (), sr_get_timeout ());
233
 
234
  if (buf == SERIAL_TIMEOUT)
235
    error ("Timeout reading from remote system.");
236
 
237
  if (sr_get_debug () > 0)
238
    printf_unfiltered ("%c", buf);
239
 
240
  return buf & 0x7f;
241
}
242
 
243
int
244
sr_pollchar ()
245
{
246
  int buf;
247
 
248
  buf = SERIAL_READCHAR (sr_get_desc (), 0);
249
  if (buf == SERIAL_TIMEOUT)
250
    buf = 0;
251
  if (sr_get_debug () > 0)
252
    {
253
      if (buf)
254
        printf_unfiltered ("%c", buf);
255
      else
256
        printf_unfiltered ("<empty character poll>");
257
    }
258
 
259
  return buf & 0x7f;
260
}
261
 
262
/* Keep discarding input from the remote system, until STRING is found.
263
   Let the user break out immediately.  */
264
void
265
sr_expect (string)
266
     char *string;
267
{
268
  char *p = string;
269
 
270
  immediate_quit = 1;
271
  while (1)
272
    {
273
      if (sr_readchar () == *p)
274
        {
275
          p++;
276
          if (*p == '\0')
277
            {
278
              immediate_quit = 0;
279
              return;
280
            }
281
        }
282
      else
283
        p = string;
284
    }
285
}
286
 
287
void
288
sr_write (a, l)
289
     char *a;
290
     int l;
291
{
292
  int i;
293
 
294
  if (SERIAL_WRITE (sr_get_desc (), a, l) != 0)
295
    perror_with_name ("sr_write: Error writing to remote");
296
 
297
  if (sr_get_debug () > 0)
298
    for (i = 0; i < l; i++)
299
      printf_unfiltered ("%c", a[i]);
300
 
301
  return;
302
}
303
 
304
void
305
sr_write_cr (s)
306
     char *s;
307
{
308
  sr_write (s, strlen (s));
309
  sr_write ("\r", 1);
310
  return;
311
}
312
 
313
int
314
sr_timed_read (buf, n)
315
     char *buf;
316
     int n;
317
{
318
  int i;
319
  char c;
320
 
321
  i = 0;
322
  while (i < n)
323
    {
324
      c = sr_readchar ();
325
 
326
      if (c == 0)
327
        return i;
328
      buf[i] = c;
329
      i++;
330
 
331
    }
332
  return i;
333
}
334
 
335
/* Get a hex digit from the remote system & return its value. If
336
   ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
337
 
338
int
339
sr_get_hex_digit (ignore_space)
340
     int ignore_space;
341
{
342
  int ch;
343
 
344
  while (1)
345
    {
346
      ch = sr_readchar ();
347
      if (ch >= '0' && ch <= '9')
348
        return ch - '0';
349
      else if (ch >= 'A' && ch <= 'F')
350
        return ch - 'A' + 10;
351
      else if (ch >= 'a' && ch <= 'f')
352
        return ch - 'a' + 10;
353
      else if (ch != ' ' || !ignore_space)
354
        {
355
          gr_expect_prompt ();
356
          error ("Invalid hex digit from remote system.");
357
        }
358
    }
359
}
360
 
361
/* Get a byte from the remote and put it in *BYT.  Accept any number
362
   leading spaces.  */
363
void
364
sr_get_hex_byte (byt)
365
     char *byt;
366
{
367
  int val;
368
 
369
  val = sr_get_hex_digit (1) << 4;
370
  val |= sr_get_hex_digit (0);
371
  *byt = val;
372
}
373
 
374
/* Read a 32-bit hex word from the remote, preceded by a space  */
375
long
376
sr_get_hex_word ()
377
{
378
  long val;
379
  int j;
380
 
381
  val = 0;
382
  for (j = 0; j < 8; j++)
383
    val = (val << 4) + sr_get_hex_digit (j == 0);
384
  return val;
385
}
386
 
387
/* Put a command string, in args, out to the remote.  The remote is assumed to
388
   be in raw mode, all writing/reading done through desc.
389
   Ouput from the remote is placed on the users terminal until the
390
   prompt from the remote is seen.
391
   FIXME: Can't handle commands that take input.  */
392
 
393
static void
394
sr_com (args, fromtty)
395
     char *args;
396
     int fromtty;
397
{
398
  sr_check_open ();
399
 
400
  if (!args)
401
    return;
402
 
403
  /* Clear all input so only command relative output is displayed */
404
 
405
  sr_write_cr (args);
406
  sr_write ("\030", 1);
407
  registers_changed ();
408
  gr_expect_prompt ();
409
}
410
 
411
void
412
gr_close (quitting)
413
     int quitting;
414
{
415
  gr_clear_all_breakpoints ();
416
 
417
  if (sr_is_open ())
418
    {
419
      SERIAL_CLOSE (sr_get_desc ());
420
      sr_set_desc (NULL);
421
    }
422
 
423
  return;
424
}
425
 
426
/* gr_detach()
427
   takes a program previously attached to and detaches it.
428
   We better not have left any breakpoints
429
   in the program or it'll die when it hits one.
430
   Close the open connection to the remote debugger.
431
   Use this when you want to detach and do something else
432
   with your gdb.  */
433
 
434
void
435
gr_detach (args, from_tty)
436
     char *args;
437
     int from_tty;
438
{
439
  if (args)
440
    error ("Argument given to \"detach\" when remotely debugging.");
441
 
442
  if (sr_is_open ())
443
    gr_clear_all_breakpoints ();
444
 
445
  pop_target ();
446
  if (from_tty)
447
    puts_filtered ("Ending remote debugging.\n");
448
 
449
  return;
450
}
451
 
452
void
453
gr_files_info (ops)
454
     struct target_ops *ops;
455
{
456
#ifdef __GO32__
457
  printf_filtered ("\tAttached to DOS asynctsr\n");
458
#else
459
  printf_filtered ("\tAttached to %s", sr_get_device ());
460
  if (baud_rate != -1)
461
    printf_filtered ("at %d baud", baud_rate);
462
  printf_filtered ("\n");
463
#endif
464
 
465
  if (exec_bfd)
466
    {
467
      printf_filtered ("\tand running program %s\n",
468
                       bfd_get_filename (exec_bfd));
469
    }
470
  printf_filtered ("\tusing the %s protocol.\n", ops->to_shortname);
471
}
472
 
473
void
474
gr_mourn ()
475
{
476
  gr_clear_all_breakpoints ();
477
  unpush_target (gr_get_ops ());
478
  generic_mourn_inferior ();
479
}
480
 
481
void
482
gr_kill ()
483
{
484
  return;
485
}
486
 
487
/* This is called not only when we first attach, but also when the
488
   user types "run" after having attached.  */
489
void
490
gr_create_inferior (execfile, args, env)
491
     char *execfile;
492
     char *args;
493
     char **env;
494
{
495
  int entry_pt;
496
 
497
  if (args && *args)
498
    error ("Can't pass arguments to remote process.");
499
 
500
  if (execfile == 0 || exec_bfd == 0)
501
    error ("No executable file specified");
502
 
503
  entry_pt = (int) bfd_get_start_address (exec_bfd);
504
  sr_check_open ();
505
 
506
  gr_kill ();
507
  gr_clear_all_breakpoints ();
508
 
509
  init_wait_for_inferior ();
510
  gr_checkin ();
511
 
512
  insert_breakpoints ();        /* Needed to get correct instruction in cache */
513
  proceed (entry_pt, -1, 0);
514
}
515
 
516
/* Given a null terminated list of strings LIST, read the input until we find one of
517
   them.  Return the index of the string found or -1 on error.  '?' means match
518
   any single character. Note that with the algorithm we use, the initial
519
   character of the string cannot recur in the string, or we will not find some
520
   cases of the string in the input.  If PASSTHROUGH is non-zero, then
521
   pass non-matching data on.  */
522
 
523
int
524
gr_multi_scan (list, passthrough)
525
     char *list[];
526
     int passthrough;
527
{
528
  char *swallowed = NULL;       /* holding area */
529
  char *swallowed_p = swallowed;        /* Current position in swallowed.  */
530
  int ch;
531
  int ch_handled;
532
  int i;
533
  int string_count;
534
  int max_length;
535
  char **plist;
536
 
537
  /* Look through the strings.  Count them.  Find the largest one so we can
538
     allocate a holding area.  */
539
 
540
  for (max_length = string_count = i = 0;
541
       list[i] != NULL;
542
       ++i, ++string_count)
543
    {
544
      int length = strlen (list[i]);
545
 
546
      if (length > max_length)
547
        max_length = length;
548
    }
549
 
550
  /* if we have no strings, then something is wrong. */
551
  if (string_count == 0)
552
    return (-1);
553
 
554
  /* otherwise, we will need a holding area big enough to hold almost two
555
     copies of our largest string.  */
556
  swallowed_p = swallowed = alloca (max_length << 1);
557
 
558
  /* and a list of pointers to current scan points. */
559
  plist = (char **) alloca (string_count * sizeof (*plist));
560
 
561
  /* and initialize */
562
  for (i = 0; i < string_count; ++i)
563
    plist[i] = list[i];
564
 
565
  for (ch = sr_readchar (); /* loop forever */ ; ch = sr_readchar ())
566
    {
567
      QUIT;                     /* Let user quit and leave process running */
568
      ch_handled = 0;
569
 
570
      for (i = 0; i < string_count; ++i)
571
        {
572
          if (ch == *plist[i] || *plist[i] == '?')
573
            {
574
              ++plist[i];
575
              if (*plist[i] == '\0')
576
                return (i);
577
 
578
              if (!ch_handled)
579
                *swallowed_p++ = ch;
580
 
581
              ch_handled = 1;
582
            }
583
          else
584
            plist[i] = list[i];
585
        }
586
 
587
      if (!ch_handled)
588
        {
589
          char *p;
590
 
591
          /* Print out any characters which have been swallowed.  */
592
          if (passthrough)
593
            {
594
              for (p = swallowed; p < swallowed_p; ++p)
595
                fputc_unfiltered (*p, gdb_stdout);
596
 
597
              fputc_unfiltered (ch, gdb_stdout);
598
            }
599
 
600
          swallowed_p = swallowed;
601
        }
602
    }
603
#if 0
604
  /* Never reached.  */
605
  return (-1);
606
#endif
607
}
608
 
609
/* Get ready to modify the registers array.  On machines which store
610
   individual registers, this doesn't need to do anything.  On machines
611
   which store all the registers in one fell swoop, this makes sure
612
   that registers contains all the registers from the program being
613
   debugged.  */
614
 
615
void
616
gr_prepare_to_store ()
617
{
618
  /* Do nothing, since we assume we can store individual regs */
619
}
620
 
621
/* Read a word from remote address ADDR and return it.
622
 * This goes through the data cache.
623
 */
624
int
625
gr_fetch_word (addr)
626
     CORE_ADDR addr;
627
{
628
  return dcache_fetch (gr_get_dcache (), addr);
629
}
630
 
631
/* Write a word WORD into remote address ADDR.
632
   This goes through the data cache.  */
633
 
634
void
635
gr_store_word (addr, word)
636
     CORE_ADDR addr;
637
     int word;
638
{
639
  dcache_poke (gr_get_dcache (), addr, word);
640
}
641
 
642
void
643
_initialize_sr_support ()
644
{
645
/* FIXME-now: if target is open... */
646
  add_show_from_set (add_set_cmd ("remotedevice", no_class,
647
                                  var_filename, (char *) &sr_settings.device,
648
                                  "Set device for remote serial I/O.\n\
649
This device is used as the serial port when debugging using remote\n\
650
targets.", &setlist),
651
                     &showlist);
652
 
653
  add_com ("remote <command>", class_obscure, sr_com,
654
           "Send a command to the remote monitor.");
655
 
656
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.