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

Subversion Repositories or1k

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Memory-access and commands for remote es1800 processes, for GDB.
2
   Copyright (C) 1988, 1992 Free Software Foundation, Inc.
3
 
4
   This file is added to GDB to make it possible to do debugging via an
5
   ES-1800 emulator. The code was originally written by Johan Holmberg
6
   TT/SJ Ericsson Telecom AB and later modified by Johan Henriksson
7
   TT/SJ. It was modified for gdb 4.0 by TX/DK Jan Nordenand by TX/DKG
8
   Harald Johansen.
9
 
10
   This file is part of GDB.
11
 
12
   GDB is free software; you can redistribute it and/or modify
13
   it under the terms of the GNU General Public License as published by
14
   the Free Software Foundation; either version 1, or (at your option)
15
   any later version.
16
 
17
   GDB is distributed in the hope that it will be useful,
18
   but WITHOUT ANY WARRANTY; without even the implied warranty of
19
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
   GNU General Public License for more details.
21
 
22
   You should have received a copy of the GNU General Public License
23
   along with this program; if not, write to the Free Software
24
   Foundation, Inc., 59 Temple Place - Suite 330,
25
   Boston, MA 02111-1307, USA.  */
26
 
27
 
28
/* Emulator communication protocol.
29
   All values are encoded in ascii hex digits.
30
 
31
   Request
32
   Command
33
   Reply
34
   read registers:
35
   DR<cr>
36
   - 0 -    - 1 -    - 2 -    - 3 -      - 4 -    - 5 -    -- 6 -   - 7 -
37
   D = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX   XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
38
   A = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX   XXXXXXXX XXXXXXXX XXXXXXXX
39
   PC = XXXXXX       SSP = XXXXXX    USP = XXXXXX     SR = XXXXXXXX
40
   >
41
   Each byte of register data is described by two hex digits.
42
 
43
   write regs
44
   D0=XXXXXXXX<cr>
45
   >D1=XXXXXXXX<cr>
46
   >D2=XXXXXXXX<cr>
47
   >D3=XXXXXXXX<cr>
48
   >D4=XXXXXXXX<cr>
49
   >D5=XXXXXXXX<cr>
50
   >D6=XXXXXXXX<cr>
51
   >D7=XXXXXXXX<cr>
52
   >A0=XXXXXXXX<cr>
53
   >A1=XXXXXXXX<cr>
54
   >A2=XXXXXXXX<cr>
55
   >A3=XXXXXXXX<cr>
56
   >A4=XXXXXXXX<cr>
57
   >A5=XXXXXXXX<cr>
58
   >A6=XXXXXXXX<cr>
59
   >A7=XXXXXXXX<cr>
60
   >SR=XXXXXXXX<cr>
61
   >PC=XXXXXX<cr>
62
   >
63
   Each byte of register data is described by two hex digits.
64
 
65
   read mem
66
   @.BAA..AA
67
   $FFFFFFXX
68
   >
69
   AA..AA is address, XXXXXXX is the contents
70
 
71
   write mem
72
   @.BAA..AA=$XXXXXXXX
73
   >
74
   AA..AA is address, XXXXXXXX is data
75
 
76
   cont
77
   PC=$AA..AA
78
   >RBK
79
   R>
80
   AA..AA is address to resume. If AA..AA is omitted, resume at same address.
81
 
82
   step
83
   PC=$AA..AA
84
   >STP
85
   R>
86
   AA..AA is address to resume. If AA..AA is omitted, resume at same address.
87
 
88
   kill req
89
   STP
90
   >
91
 */
92
 
93
 
94
#include <stdio.h>
95
#include <signal.h>
96
#include <sys/ioctl.h>
97
#include <sys/file.h>
98
#include <errno.h>
99
#include <ctype.h>
100
#include <setjmp.h>
101
#include <fcntl.h>
102
#include "defs.h"
103
#include "gdb_string.h"
104
#include "frame.h"
105
#include "inferior.h"
106
#include "target.h"
107
#include "gdb_wait.h"
108
#include "command.h"
109
#include "remote-utils.h"
110
#include "gdbcore.h"
111
#include "serial.h"
112
 
113
/* Prototypes for local functions */
114
 
115
static void
116
es1800_child_detach PARAMS ((char *, int));
117
 
118
static void
119
es1800_child_open PARAMS ((char *, int));
120
 
121
static void
122
es1800_transparent PARAMS ((char *, int));
123
 
124
static void
125
es1800_create_inferior PARAMS ((char *, char *, char **));
126
 
127
static void
128
es1800_load PARAMS ((char *, int));
129
 
130
static void
131
es1800_kill PARAMS ((void));
132
 
133
static int
134
verify_break PARAMS ((int));
135
 
136
static int
137
es1800_remove_breakpoint PARAMS ((CORE_ADDR, char *));
138
 
139
static int
140
es1800_insert_breakpoint PARAMS ((CORE_ADDR, char *));
141
 
142
static void
143
es1800_files_info PARAMS ((struct target_ops *));
144
 
145
static int
146
es1800_xfer_inferior_memory PARAMS ((CORE_ADDR, char *, int, int,
147
                                     struct target_ops *));
148
 
149
static void
150
es1800_prepare_to_store PARAMS ((void));
151
 
152
static int es1800_wait PARAMS ((int, struct target_waitstatus *));
153
 
154
static void es1800_resume PARAMS ((int, int, enum target_signal));
155
 
156
static void
157
es1800_detach PARAMS ((char *, int));
158
 
159
static void
160
es1800_attach PARAMS ((char *, int));
161
 
162
static int
163
damn_b PARAMS ((char *));
164
 
165
static void
166
es1800_open PARAMS ((char *, int));
167
 
168
static void
169
es1800_timer PARAMS ((void));
170
 
171
static void
172
es1800_reset PARAMS ((char *));
173
 
174
static void
175
es1800_request_quit PARAMS ((void));
176
 
177
static int
178
readchar PARAMS ((void));
179
 
180
static void
181
expect PARAMS ((char *, int));
182
 
183
static void
184
expect_prompt PARAMS ((void));
185
 
186
static void
187
download PARAMS ((FILE *, int, int));
188
 
189
#if 0
190
static void
191
bfd_copy PARAMS ((bfd *, bfd *));
192
#endif
193
 
194
static void
195
get_break_addr PARAMS ((int, CORE_ADDR *));
196
 
197
static int
198
fromhex PARAMS ((int));
199
 
200
static int
201
tohex PARAMS ((int));
202
 
203
static void
204
es1800_close PARAMS ((int));
205
 
206
static void
207
es1800_fetch_registers PARAMS ((void));
208
 
209
static void
210
es1800_fetch_register PARAMS ((int));
211
 
212
static void
213
es1800_store_register PARAMS ((int));
214
 
215
static void
216
es1800_read_bytes PARAMS ((CORE_ADDR, char *, int));
217
 
218
static void
219
es1800_write_bytes PARAMS ((CORE_ADDR, char *, int));
220
 
221
static void
222
send_with_reply PARAMS ((char *, char *, int));
223
 
224
static void
225
send_command PARAMS ((char *));
226
 
227
static void
228
send PARAMS ((char *));
229
 
230
static void
231
getmessage PARAMS ((char *, int));
232
 
233
static void
234
es1800_mourn_inferior PARAMS ((void));
235
 
236
static void
237
es1800_create_break_insn PARAMS ((char *, int));
238
 
239
static void
240
es1800_init_break PARAMS ((char *, int));
241
 
242
/* Local variables */
243
 
244
/* FIXME: Convert this to use "set remotedebug" instead.  */
245
#define LOG_FILE "es1800.log"
246
#if defined (LOG_FILE)
247
static FILE *log_file;
248
#endif
249
 
250
extern struct target_ops es1800_ops;    /* Forward decl */
251
extern struct target_ops es1800_child_ops;      /* Forward decl */
252
 
253
static int kiodebug;
254
static int timeout = 100;
255
static char *savename;          /* Name of i/o device used */
256
static serial_ttystate es1800_saved_ttystate;
257
static int es1800_fc_save;      /* Save fcntl state */
258
 
259
/* indicates that the emulator uses 32-bit data-adress (68020-mode)
260
   instead of 24-bit (68000 -mode) */
261
 
262
static int m68020;
263
 
264
#define MODE (m68020 ? "M68020" : "M68000" )
265
#define ES1800_BREAK_VEC (0xf)
266
 
267
/* Descriptor for I/O to remote machine.  Initialize it to NULL so that
268
   es1800_open knows that we don't have a file open when the program
269
   starts.  */
270
 
271
static serial_t es1800_desc = NULL;
272
 
273
#define PBUFSIZ 1000
274
#define HDRLEN sizeof("@.BAAAAAAAA=$VV\r")
275
 
276
/* Maximum number of bytes to read/write at once.  The value here
277
   is chosen to fill up a packet.  */
278
 
279
#define MAXBUFBYTES ((PBUFSIZ-150)*16/75 )
280
 
281
static int es1800_break_vec = 0;
282
static char es1800_break_insn[2];
283
static long es1800_break_address;
284
static void (*old_sigint) ();   /* Old signal-handler for sigint */
285
static jmp_buf interrupt;
286
 
287
/* Local signalhandler to allow breaking tranfers or program run.
288
   Rely on global variables: old_sigint(), interrupt */
289
 
290
static void
291
es1800_request_quit ()
292
{
293
  /* restore original signalhandler */
294
  signal (SIGINT, old_sigint);
295
  longjmp (interrupt, 1);
296
}
297
 
298
 
299
/* Reset emulator.
300
   Sending reset character(octal 32) to emulator.
301
   quit - return to '(esgdb)' prompt or continue        */
302
 
303
static void
304
es1800_reset (quit)
305
     char *quit;
306
{
307
  char buf[80];
308
 
309
  if (quit)
310
    {
311
      printf ("\nResetting emulator...  ");
312
    }
313
  strcpy (buf, "\032");
314
  send (buf);
315
  expect_prompt ();
316
  if (quit)
317
    {
318
      error ("done\n");
319
    }
320
}
321
 
322
 
323
/* Open a connection to a remote debugger and push the new target
324
   onto the stack. Check if the emulator is responding and find out
325
   what kind of processor the emulator is connected to.
326
   Initiate the breakpoint handling in the emulator.
327
 
328
   name     - the filename used for communication (ex. '/dev/tta')
329
   from_tty - says whether to be verbose or not */
330
 
331
static void
332
es1800_open (name, from_tty)
333
     char *name;
334
     int from_tty;
335
{
336
  char buf[PBUFSIZ];
337
  char *p;
338
  int i, fcflag;
339
 
340
  m68020 = 0;
341
 
342
  if (!name)                    /* no device name given in target command */
343
    {
344
      error_no_arg ("serial port device name");
345
    }
346
 
347
  target_preopen (from_tty);
348
  es1800_close (0);
349
 
350
  /* open the device and configure it for communication */
351
 
352
#ifndef DEBUG_STDIN
353
 
354
  es1800_desc = SERIAL_OPEN (name);
355
  if (es1800_desc == NULL)
356
    {
357
      perror_with_name (name);
358
    }
359
  savename = savestring (name, strlen (name));
360
 
361
  es1800_saved_ttystate = SERIAL_GET_TTY_STATE (es1800_desc);
362
 
363
  if ((fcflag = fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_GETFL, 0)) == -1)
364
    {
365
      perror_with_name ("fcntl serial");
366
    }
367
  es1800_fc_save = fcflag;
368
 
369
  fcflag = (fcflag & (FREAD | FWRITE));         /* mask out any funny stuff */
370
  if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_SETFL, fcflag) == -1)
371
    {
372
      perror_with_name ("fcntl serial");
373
    }
374
 
375
  if (baud_rate != -1)
376
    {
377
      if (SERIAL_SETBAUDRATE (es1800_desc, baud_rate))
378
        {
379
          SERIAL_CLOSE (es1800_desc);
380
          perror_with_name (name);
381
        }
382
    }
383
 
384
  SERIAL_RAW (es1800_desc);
385
 
386
  /* If there is something sitting in the buffer we might take it as a
387
     response to a command, which would be bad.  */
388
  SERIAL_FLUSH_INPUT (es1800_desc);
389
 
390
#endif /* DEBUG_STDIN */
391
 
392
  push_target (&es1800_ops);    /* Switch to using remote target now */
393
  if (from_tty)
394
    {
395
      printf ("Remote ES1800 debugging using %s\n", name);
396
    }
397
 
398
#if defined (LOG_FILE)
399
 
400
  log_file = fopen (LOG_FILE, "w");
401
  if (log_file == NULL)
402
    {
403
      perror_with_name (LOG_FILE);
404
    }
405
 
406
#endif /* LOG_FILE */
407
 
408
  /* Hello?  Are you there?, also check mode  */
409
 
410
  /*  send_with_reply( "DB 0 TO 1", buf, sizeof(buf)); */
411
  /*  for (p = buf, i = 0; *p++ =='0';)  *//* count the number of zeros */
412
  /*      i++; */
413
 
414
  send ("\032");
415
  getmessage (buf, sizeof (buf));       /* send reset character */
416
 
417
  if (from_tty)
418
    {
419
      printf ("Checking mode.... ");
420
    }
421
  /*  m68020 = (i==8); *//* if eight zeros then we are in m68020 mode */
422
 
423
  /* What kind of processor am i talking to ? */
424
  p = buf;
425
  while (*p++ != '\n')
426
    {;
427
    }
428
  while (*p++ != '\n')
429
    {;
430
    }
431
  while (*p++ != '\n')
432
    {;
433
    }
434
  for (i = 0; i < 20; i++, p++)
435
    {;
436
    }
437
  m68020 = !strncmp (p, "68020", 5);
438
  if (from_tty)
439
    {
440
      printf ("You are in %s(%c%c%c%c%c)-mode\n", MODE, p[0], p[1], p[2],
441
              p[3], p[4]);
442
    }
443
 
444
  /* if no init_break statement is present in .gdb file we have to check
445
     whether to download a breakpoint routine or not */
446
 
447
#if 0
448
  if ((es1800_break_vec == 0) || (verify_break (es1800_break_vec) != 0)
449
      && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
450
    {
451
      CORE_ADDR memaddress;
452
      printf ("Give the start address of the breakpoint routine: ");
453
      scanf ("%li", &memaddress);
454
      es1800_init_break ((es1800_break_vec ? es1800_break_vec :
455
                          ES1800_BREAK_VEC), memaddress);
456
    }
457
#endif
458
 
459
}
460
 
461
/*  Close out all files and local state before this target loses control.
462
   quitting - are we quitting gdb now? */
463
 
464
static void
465
es1800_close (quitting)
466
     int quitting;
467
{
468
  if (es1800_desc != NULL)
469
    {
470
      printf ("\nClosing connection to emulator...\n");
471
      if (SERIAL_SET_TTY_STATE (es1800_desc, es1800_saved_ttystate) < 0)
472
        print_sys_errmsg ("warning: unable to restore tty state", errno);
473
      fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_SETFL, es1800_fc_save);
474
      SERIAL_CLOSE (es1800_desc);
475
      es1800_desc = NULL;
476
    }
477
  if (savename != NULL)
478
    {
479
      free (savename);
480
    }
481
  savename = NULL;
482
 
483
#if defined (LOG_FILE)
484
 
485
  if (log_file != NULL)
486
    {
487
      if (ferror (log_file))
488
        {
489
          printf ("Error writing log file.\n");
490
        }
491
      if (fclose (log_file) != 0)
492
        {
493
          printf ("Error closing log file.\n");
494
        }
495
      log_file = NULL;
496
    }
497
 
498
#endif /* LOG_FILE */
499
 
500
}
501
 
502
/*  Attaches to a process on the target side
503
   proc_id  - the id of the process to be attached.
504
   from_tty - says whether to be verbose or not */
505
 
506
static void
507
es1800_attach (args, from_tty)
508
     char *args;
509
     int from_tty;
510
{
511
  error ("Cannot attach to pid %s, this feature is not implemented yet.",
512
         args);
513
}
514
 
515
 
516
/* Takes a program previously attached to and detaches it.
517
   We better not have left any breakpoints
518
   in the program or it'll die when it hits one.
519
   Close the open connection to the remote debugger.
520
   Use this when you want to detach and do something else
521
   with your gdb.
522
 
523
   args     - arguments given to the 'detach' command
524
   from_tty - says whether to be verbose or not */
525
 
526
static void
527
es1800_detach (args, from_tty)
528
     char *args;
529
     int from_tty;
530
{
531
  if (args)
532
    {
533
      error ("Argument given to \"detach\" when remotely debugging.");
534
    }
535
  pop_target ();
536
  if (from_tty)
537
    {
538
      printf ("Ending es1800 remote debugging.\n");
539
    }
540
}
541
 
542
 
543
/* Tell the remote machine to resume.
544
   step    - single-step or run free
545
   siggnal - the signal value to be given to the target (0 = no signal) */
546
 
547
static void
548
es1800_resume (pid, step, siggnal)
549
     int pid;
550
     int step;
551
     enum target_signal siggnal;
552
{
553
  char buf[PBUFSIZ];
554
 
555
  if (siggnal)
556
    {
557
      error ("Can't send signals to a remote system.");
558
    }
559
  if (step)
560
    {
561
      strcpy (buf, "STP\r");
562
      send (buf);
563
    }
564
  else
565
    {
566
      send_command ("RBK");
567
    }
568
}
569
 
570
/* Wait until the remote machine stops, then return,
571
   storing status in STATUS just as `wait' would.
572
   status -  */
573
 
574
static int
575
es1800_wait (pid, status)
576
     int pid;
577
     struct target_waitstatus *status;
578
{
579
  unsigned char buf[PBUFSIZ];
580
  int old_timeout = timeout;
581
 
582
  status->kind = TARGET_WAITKIND_EXITED;
583
  status->value.integer = 0;
584
 
585
  timeout = 0;                   /* Don't time out -- user program is running. */
586
  if (!setjmp (interrupt))
587
    {
588
      old_sigint = signal (SIGINT, es1800_request_quit);
589
      while (1)
590
        {
591
          getmessage (buf, sizeof (buf));
592
          if (strncmp (buf, "\r\n* BREAK *", 11) == 0)
593
            {
594
              status->kind = TARGET_WAITKIND_STOPPED;
595
              status->value.sig = TARGET_SIGNAL_TRAP;
596
              send_command ("STP");     /* Restore stack and PC and such */
597
              if (m68020)
598
                {
599
                  send_command ("STP");
600
                }
601
              break;
602
            }
603
          if (strncmp (buf, "STP\r\n ", 6) == 0)
604
            {
605
              status->kind = TARGET_WAITKIND_STOPPED;
606
              status->value.sig = TARGET_SIGNAL_TRAP;
607
              break;
608
            }
609
          if (buf[strlen (buf) - 2] == 'R')
610
            {
611
              printf ("Unexpected emulator reply: \n%s\n", buf);
612
            }
613
          else
614
            {
615
              printf ("Unexpected stop: \n%s\n", buf);
616
              status->kind = TARGET_WAITKIND_STOPPED;
617
              status->value.sig = TARGET_SIGNAL_QUIT;
618
              break;
619
            }
620
        }
621
    }
622
  else
623
    {
624
      fflush (stdin);
625
      printf ("\nStopping emulator...");
626
      if (!setjmp (interrupt))
627
        {
628
          old_sigint = signal (SIGINT, es1800_request_quit);
629
          send_command ("STP");
630
          printf (" emulator stopped\n");
631
          status->kind = TARGET_WAITKIND_STOPPED;
632
          status->value.sig = TARGET_SIGNAL_INT;
633
        }
634
      else
635
        {
636
          fflush (stdin);
637
          es1800_reset ((char *) 1);
638
        }
639
    }
640
  signal (SIGINT, old_sigint);
641
  timeout = old_timeout;
642
  return (0);
643
}
644
 
645
 
646
/* Fetch register values from remote machine.
647
   regno - the register to be fetched (fetch all registers if -1) */
648
 
649
static void
650
es1800_fetch_register (regno)
651
     int regno;
652
{
653
  char buf[PBUFSIZ];
654
  int k;
655
  int r;
656
  char *p;
657
  static char regtab[18][4] =
658
  {
659
    "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
660
    "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
661
    "SR ", "PC "
662
  };
663
 
664
  if ((regno < 15) || (regno == 16) || (regno == 17))
665
    {
666
      r = regno * 4;
667
      send_with_reply (regtab[regno], buf, sizeof (buf));
668
      p = buf;
669
      for (k = 0; k < 4; k++)
670
        {
671
          if ((p[k * 2 + 1] == 0) || (p[k * 2 + 2] == 0))
672
            {
673
              error ("Emulator reply is too short: %s", buf);
674
            }
675
          registers[r++] = (fromhex (p[k * 2 + 1]) * 16) + fromhex (p[k * 2 + 2]);
676
        }
677
    }
678
  else
679
    {
680
      es1800_fetch_registers ();
681
    }
682
}
683
 
684
/* Read the remote registers into REGISTERS.
685
   Always fetches all registers. */
686
 
687
static void
688
es1800_fetch_registers ()
689
{
690
  char buf[PBUFSIZ];
691
  char SR_buf[PBUFSIZ];
692
  int i;
693
  int k;
694
  int r;
695
  char *p;
696
 
697
  send_with_reply ("DR", buf, sizeof (buf));
698
 
699
  /* Reply is edited to a string that describes registers byte by byte,
700
     each byte encoded as two hex characters.  */
701
 
702
  p = buf;
703
  r = 0;
704
 
705
  /*  parsing row one - D0-D7-registers  */
706
 
707
  while (*p++ != '\n')
708
    {;
709
    }
710
  for (i = 4; i < 70; i += (i == 39 ? 3 : 1))
711
    {
712
      for (k = 0; k < 4; k++)
713
        {
714
          if (p[i + 0] == 0 || p[i + 1] == 0)
715
            {
716
              error ("Emulator reply is too short: %s", buf);
717
            }
718
          registers[r++] = (fromhex (p[i + 0]) * 16) + fromhex (p[i + 1]);
719
          i += 2;
720
        }
721
    }
722
  p += i;
723
 
724
  /*  parsing row two - A0-A6-registers  */
725
 
726
  while (*p++ != '\n')
727
    {;
728
    }
729
  for (i = 4; i < 61; i += (i == 39 ? 3 : 1))
730
    {
731
      for (k = 0; k < 4; k++)
732
        {
733
          if (p[i + 0] == 0 || p[i + 1] == 0)
734
            {
735
              error ("Emulator reply is too short: %s", buf);
736
            }
737
          registers[r++] = (fromhex (p[i + 0])) * 16 + fromhex (p[i + 1]);
738
          i += 2;
739
        }
740
    }
741
  p += i;
742
 
743
  while (*p++ != '\n')
744
    {;
745
    }
746
 
747
  /* fetch SSP-, SR- and PC-registers  */
748
 
749
  /* first - check STATUS-word and decide which stackpointer to use */
750
 
751
  send_with_reply ("SR", SR_buf, sizeof (SR_buf));
752
  p = SR_buf;
753
  p += 5;
754
 
755
  if (m68020)
756
    {
757
      if (*p == '3')            /* use masterstackpointer MSP */
758
        {
759
          send_with_reply ("MSP", buf, sizeof (buf));
760
        }
761
      else if (*p == '2')       /* use interruptstackpointer ISP  */
762
        {
763
          send_with_reply ("ISP", buf, sizeof (buf));
764
        }
765
      else
766
        /* use userstackpointer USP  */
767
        {
768
          send_with_reply ("USP", buf, sizeof (buf));
769
        }
770
      p = buf;
771
      for (k = 0; k < 4; k++)
772
        {
773
          if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
774
            {
775
              error ("Emulator reply is too short: %s", buf);
776
            }
777
          registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
778
        }
779
 
780
      p = SR_buf;
781
      for (k = 0; k < 4; k++)
782
        {
783
          if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
784
            {
785
              error ("Emulator reply is too short: %s", buf);
786
            }
787
          registers[r++] =
788
            fromhex (SR_buf[k * 2 + 1]) * 16 + fromhex (SR_buf[k * 2 + 2]);
789
        }
790
      send_with_reply ("PC", buf, sizeof (buf));
791
      p = buf;
792
      for (k = 0; k < 4; k++)
793
        {
794
          if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
795
            {
796
              error ("Emulator reply is too short: %s", buf);
797
            }
798
          registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
799
        }
800
    }
801
  else
802
    /* 68000-mode */
803
    {
804
      if (*p == '2')            /* use supervisorstackpointer SSP  */
805
        {
806
          send_with_reply ("SSP", buf, sizeof (buf));
807
        }
808
      else
809
        /* use userstackpointer USP  */
810
        {
811
          send_with_reply ("USP", buf, sizeof (buf));
812
        }
813
 
814
      /* fetch STACKPOINTER */
815
 
816
      p = buf;
817
      for (k = 0; k < 4; k++)
818
        {
819
          if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
820
            {
821
              error ("Emulator reply is too short: %s", buf);
822
            }
823
          registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
824
        }
825
 
826
      /* fetch STATUS */
827
 
828
      p = SR_buf;
829
      for (k = 0; k < 4; k++)
830
        {
831
          if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
832
            {
833
              error ("Emulator reply is too short: %s", buf);
834
            }
835
          registers[r++] =
836
            fromhex (SR_buf[k * 2 + 1]) * 16 + fromhex (SR_buf[k * 2 + 2]);
837
        }
838
 
839
      /* fetch PC */
840
 
841
      send_with_reply ("PC", buf, sizeof (buf));
842
      p = buf;
843
      for (k = 0; k < 4; k++)
844
        {
845
          if (p[k * 2 + 1] == 0 || p[k * 2 + 2] == 0)
846
            {
847
              error ("Emulator reply is too short: %s", buf);
848
            }
849
          registers[r++] = fromhex (buf[k * 2 + 1]) * 16 + fromhex (buf[k * 2 + 2]);
850
        }
851
    }
852
}
853
 
854
/* Store register value, located in REGISTER, on the target processor.
855
   regno - the register-number of the register to store
856
   (-1 means store them all)
857
   FIXME: Return errno value.  */
858
 
859
static void
860
es1800_store_register (regno)
861
     int regno;
862
{
863
 
864
  static char regtab[18][4] =
865
  {
866
    "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
867
    "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
868
    "SR ", "PC "
869
  };
870
 
871
  char buf[PBUFSIZ];
872
  char SR_buf[PBUFSIZ];
873
  char stack_pointer[4];
874
  char *p;
875
  int i;
876
  int j;
877
  int k;
878
  unsigned char *r;
879
 
880
  r = (unsigned char *) registers;
881
 
882
  if (regno == -1)              /* write all registers */
883
    {
884
      j = 0;
885
      k = 18;
886
    }
887
  else
888
    /* write one register */
889
    {
890
      j = regno;
891
      k = regno + 1;
892
      r += regno * 4;
893
    }
894
 
895
  if ((regno == -1) || (regno == 15))
896
    {
897
      /* fetch current status */
898
      send_with_reply ("SR", SR_buf, sizeof (SR_buf));
899
      p = SR_buf;
900
      p += 5;
901
      if (m68020)
902
        {
903
          if (*p == '3')        /* use masterstackpointer MSP */
904
            {
905
              strcpy (stack_pointer, "MSP");
906
            }
907
          else
908
            {
909
              if (*p == '2')    /* use interruptstackpointer ISP  */
910
                {
911
                  strcpy (stack_pointer, "ISP");
912
                }
913
              else
914
                {
915
                  strcpy (stack_pointer, "USP");        /* use userstackpointer USP  */
916
                }
917
            }
918
        }
919
      else
920
        /* 68000-mode */
921
        {
922
          if (*p == '2')        /* use supervisorstackpointer SSP  */
923
            {
924
              strcpy (stack_pointer, "SSP");
925
            }
926
          else
927
            {
928
              strcpy (stack_pointer, "USP");    /* use userstackpointer USP  */
929
            }
930
        }
931
      strcpy (regtab[15], stack_pointer);
932
    }
933
 
934
  for (i = j; i < k; i++)
935
    {
936
      buf[0] = regtab[i][0];
937
      buf[1] = regtab[i][1];
938
      buf[2] = regtab[i][2];
939
      buf[3] = '=';
940
      buf[4] = '$';
941
      buf[5] = tohex ((*r >> 4) & 0x0f);
942
      buf[6] = tohex (*r++ & 0x0f);
943
      buf[7] = tohex ((*r >> 4) & 0x0f);
944
      buf[8] = tohex (*r++ & 0x0f);
945
      buf[9] = tohex ((*r >> 4) & 0x0f);
946
      buf[10] = tohex (*r++ & 0x0f);
947
      buf[11] = tohex ((*r >> 4) & 0x0f);
948
      buf[12] = tohex (*r++ & 0x0f);
949
      buf[13] = 0;
950
 
951
      send_with_reply (buf, buf, sizeof (buf));         /* FIXME, reply not used? */
952
    }
953
}
954
 
955
 
956
/* Prepare to store registers.  */
957
 
958
static void
959
es1800_prepare_to_store ()
960
{
961
  /* Do nothing, since we can store individual regs */
962
}
963
 
964
/* Convert hex digit A to a number.  */
965
 
966
static int
967
fromhex (a)
968
     int a;
969
{
970
  if (a >= '0' && a <= '9')
971
    {
972
      return a - '0';
973
    }
974
  else if (a >= 'a' && a <= 'f')
975
    {
976
      return a - 'a' + 10;
977
    }
978
  else if (a >= 'A' && a <= 'F')
979
    {
980
      return a - 'A' + 10;
981
    }
982
  else
983
    {
984
      error ("Reply contains invalid hex digit");
985
    }
986
  return (-1);
987
}
988
 
989
 
990
/* Convert number NIB to a hex digit.  */
991
 
992
static int
993
tohex (nib)
994
     int nib;
995
{
996
  if (nib < 10)
997
    {
998
      return ('0' + nib);
999
    }
1000
  else
1001
    {
1002
      return ('A' + nib - 10);
1003
    }
1004
}
1005
 
1006
/* Read or write LEN bytes from inferior memory at MEMADDR, transferring
1007
   to or from debugger address MYADDR.  Write to inferior if WRITE is
1008
   nonzero.  Returns length of data written or read; 0 for error.
1009
 
1010
   memaddr - the target's address
1011
   myaddr  - gdb's address
1012
   len     - number of bytes
1013
   write   - write if != 0 otherwise read       */
1014
 
1015
static int
1016
es1800_xfer_inferior_memory (memaddr, myaddr, len, write, tops)
1017
     CORE_ADDR memaddr;
1018
     char *myaddr;
1019
     int len;
1020
     int write;
1021
     struct target_ops *tops;   /* Unused */
1022
{
1023
  int origlen = len;
1024
  int xfersize;
1025
 
1026
  while (len > 0)
1027
    {
1028
      xfersize = len > MAXBUFBYTES ? MAXBUFBYTES : len;
1029
      if (write)
1030
        {
1031
          es1800_write_bytes (memaddr, myaddr, xfersize);
1032
        }
1033
      else
1034
        {
1035
          es1800_read_bytes (memaddr, myaddr, xfersize);
1036
        }
1037
      memaddr += xfersize;
1038
      myaddr += xfersize;
1039
      len -= xfersize;
1040
    }
1041
  return (origlen);             /* no error possible */
1042
}
1043
 
1044
 
1045
/* Write memory data directly to the emulator.
1046
   This does not inform the data cache; the data cache uses this.
1047
   MEMADDR is the address in the remote memory space.
1048
   MYADDR is the address of the buffer in our space.
1049
   LEN is the number of bytes.
1050
 
1051
   memaddr - the target's address
1052
   myaddr  - gdb's address
1053
   len     - number of bytes   */
1054
 
1055
static void
1056
es1800_write_bytes (memaddr, myaddr, len)
1057
     CORE_ADDR memaddr;
1058
     char *myaddr;
1059
     int len;
1060
{
1061
  char buf[PBUFSIZ];
1062
  int i;
1063
  char *p;
1064
 
1065
  p = myaddr;
1066
  for (i = 0; i < len; i++)
1067
    {
1068
      sprintf (buf, "@.B$%x=$%x", memaddr + i, (*p++) & 0xff);
1069
      send_with_reply (buf, buf, sizeof (buf));         /* FIXME send_command? */
1070
    }
1071
}
1072
 
1073
 
1074
/* Read memory data directly from the emulator.
1075
   This does not use the data cache; the data cache uses this.
1076
 
1077
   memaddr - the target's address
1078
   myaddr  - gdb's address
1079
   len     - number of bytes   */
1080
 
1081
static void
1082
es1800_read_bytes (memaddr, myaddr, len)
1083
     CORE_ADDR memaddr;
1084
     char *myaddr;
1085
     int len;
1086
{
1087
  static int DB_tab[16] =
1088
  {8, 11, 14, 17, 20, 23, 26, 29, 34, 37, 40, 43, 46, 49, 52, 55};
1089
  char buf[PBUFSIZ];
1090
  int i;
1091
  int low_addr;
1092
  char *p;
1093
  char *b;
1094
 
1095
  if (len > PBUFSIZ / 2 - 1)
1096
    {
1097
      abort ();
1098
    }
1099
 
1100
  if (len == 1)                 /* The emulator does not like expressions like:  */
1101
    {
1102
      len = 2;                  /* DB.B $20018 TO $20018                       */
1103
    }
1104
 
1105
  /* Reply describes registers byte by byte, each byte encoded as two hex
1106
     characters.  */
1107
 
1108
  sprintf (buf, "DB.B $%x TO $%x", memaddr, memaddr + len - 1);
1109
  send_with_reply (buf, buf, sizeof (buf));
1110
  b = buf;
1111
  low_addr = memaddr & 0x0f;
1112
  for (i = low_addr; i < low_addr + len; i++)
1113
    {
1114
      if ((!(i % 16)) && i)
1115
        {                       /* if (i = 16,32,48)  */
1116
          while (*p++ != '\n')
1117
            {;
1118
            }
1119
          b = p;
1120
        }
1121
      p = b + DB_tab[i % 16] + (m68020 ? 2 : 0);
1122
      if (p[0] == 32 || p[1] == 32)
1123
        {
1124
          error ("Emulator reply is too short: %s", buf);
1125
        }
1126
      myaddr[i - low_addr] = fromhex (p[0]) * 16 + fromhex (p[1]);
1127
    }
1128
}
1129
 
1130
/* Information about the current target  */
1131
 
1132
static void
1133
es1800_files_info (tops)
1134
     struct target_ops *tops;   /* Unused */
1135
{
1136
  printf ("ES1800 Attached to %s at %d baud in %s mode\n", savename, 19200,
1137
          MODE);
1138
}
1139
 
1140
 
1141
/* We read the contents of the target location and stash it,
1142
   then overwrite it with a breakpoint instruction.
1143
 
1144
   addr           - is the target location in the target machine.
1145
   contents_cache - is a pointer to memory allocated for saving the target contents.
1146
   It is guaranteed by the caller to be long enough to save sizeof
1147
   BREAKPOINT bytes.
1148
 
1149
   FIXME: This size is target_arch dependent and should be available in
1150
   the target_arch transfer vector, if we ever have one...  */
1151
 
1152
static int
1153
es1800_insert_breakpoint (addr, contents_cache)
1154
     CORE_ADDR addr;
1155
     char *contents_cache;
1156
{
1157
  int val;
1158
 
1159
  val = target_read_memory (addr, contents_cache, sizeof (es1800_break_insn));
1160
 
1161
  if (val == 0)
1162
    {
1163
      val = target_write_memory (addr, es1800_break_insn,
1164
                                 sizeof (es1800_break_insn));
1165
    }
1166
 
1167
  return (val);
1168
}
1169
 
1170
 
1171
/* Write back the stashed instruction
1172
 
1173
   addr           - is the target location in the target machine.
1174
   contents_cache - is a pointer to memory allocated for saving the target contents.
1175
   It is guaranteed by the caller to be long enough to save sizeof
1176
   BREAKPOINT bytes.    */
1177
 
1178
static int
1179
es1800_remove_breakpoint (addr, contents_cache)
1180
     CORE_ADDR addr;
1181
     char *contents_cache;
1182
{
1183
 
1184
  return (target_write_memory (addr, contents_cache,
1185
                               sizeof (es1800_break_insn)));
1186
}
1187
 
1188
/* create_break_insn ()
1189
   Primitive datastructures containing the es1800 breakpoint instruction  */
1190
 
1191
static void
1192
es1800_create_break_insn (ins, vec)
1193
     char *ins;
1194
     int vec;
1195
{
1196
  if (vec == 15)
1197
    {
1198
      ins[0] = 0x4e;
1199
      ins[1] = 0x4f;
1200
    }
1201
}
1202
 
1203
 
1204
/* verify_break ()
1205
   Seach for breakpoint routine in emulator memory.
1206
   returns non-zero on failure
1207
   vec - trap vector used for breakpoints  */
1208
 
1209
static int
1210
verify_break (vec)
1211
     int vec;
1212
{
1213
  CORE_ADDR memaddress;
1214
  char buf[8];
1215
  char *instr = "NqNqNqNs";     /* breakpoint routine */
1216
  int status;
1217
 
1218
  get_break_addr (vec, &memaddress);
1219
 
1220
  if (memaddress)
1221
    {
1222
      status = target_read_memory (memaddress, buf, 8);
1223
      if (status != 0)
1224
        {
1225
          memory_error (status, memaddress);
1226
        }
1227
      return (STRCMP (instr, buf));
1228
    }
1229
  return (-1);
1230
}
1231
 
1232
 
1233
/* get_break_addr ()
1234
   find address of breakpint routine
1235
   vec - trap vector used for breakpoints
1236
   addrp - store the address here       */
1237
 
1238
static void
1239
get_break_addr (vec, addrp)
1240
     int vec;
1241
     CORE_ADDR *addrp;
1242
{
1243
  CORE_ADDR memaddress = 0;
1244
  int status;
1245
  int k;
1246
  char buf[PBUFSIZ];
1247
  char base_addr[4];
1248
  char *p;
1249
 
1250
  if (m68020)
1251
    {
1252
      send_with_reply ("VBR ", buf, sizeof (buf));
1253
      p = buf;
1254
      for (k = 0; k < 4; k++)
1255
        {
1256
          if ((p[k * 2 + 1] == 0) || (p[k * 2 + 2] == 0))
1257
            {
1258
              error ("Emulator reply is too short: %s", buf);
1259
            }
1260
          base_addr[k] = (fromhex (p[k * 2 + 1]) * 16) + fromhex (p[k * 2 + 2]);
1261
        }
1262
      /* base addr of exception vector table */
1263
      memaddress = *((CORE_ADDR *) base_addr);
1264
    }
1265
 
1266
  memaddress += (vec + 32) * 4; /* address of trap vector */
1267
  status = target_read_memory (memaddress, (char *) addrp, 4);
1268
  if (status != 0)
1269
    {
1270
      memory_error (status, memaddress);
1271
    }
1272
}
1273
 
1274
 
1275
/* Kill an inferior process */
1276
 
1277
static void
1278
es1800_kill ()
1279
{
1280
  if (inferior_pid != 0)
1281
    {
1282
      inferior_pid = 0;
1283
      es1800_mourn_inferior ();
1284
    }
1285
}
1286
 
1287
 
1288
/* Load a file to the ES1800 emulator.
1289
   Converts the file from a.out format into Extended Tekhex format
1290
   before the file is loaded.
1291
   Also loads the trap routine, and sets the ES1800 breakpoint on it
1292
   filename - the a.out to be loaded
1293
   from_tty - says whether to be verbose or not
1294
   FIXME Uses emulator overlay memory for trap routine  */
1295
 
1296
static void
1297
es1800_load (filename, from_tty)
1298
     char *filename;
1299
     int from_tty;
1300
{
1301
 
1302
  FILE *instream;
1303
  char loadname[15];
1304
  char buf[160];
1305
  struct cleanup *old_chain;
1306
  int es1800_load_format = 5;
1307
 
1308
  if (es1800_desc == NULL)
1309
    {
1310
      printf ("No emulator attached, type emulator-command first\n");
1311
      return;
1312
    }
1313
 
1314
  filename = tilde_expand (filename);
1315
  make_cleanup (free, filename);
1316
 
1317
  switch (es1800_load_format)
1318
    {
1319
    case 2:                     /* Extended Tekhex  */
1320
      if (from_tty)
1321
        {
1322
          printf ("Converting \"%s\" to Extended Tekhex Format\n", filename);
1323
        }
1324
      sprintf (buf, "tekhex %s", filename);
1325
      system (buf);
1326
      sprintf (loadname, "out.hex");
1327
      break;
1328
 
1329
    case 5:                     /* Motorola S-rec  */
1330
      if (from_tty)
1331
        {
1332
          printf ("Converting \"%s\" to Motorola S-record format\n",
1333
                  filename);
1334
        }
1335
      /* in the future the source code in copy (part of binutils-1.93) will
1336
         be included in this file */
1337
      sprintf (buf,
1338
               "copy -s \"a.out-sunos-big\" -d \"srec\" %s /tmp/out.hex",
1339
               filename);
1340
      system (buf);
1341
      sprintf (loadname, "/tmp/out.hex");
1342
      break;
1343
 
1344
    default:
1345
      error ("Downloading format not defined\n");
1346
    }
1347
 
1348
  breakpoint_init_inferior ();
1349
  inferior_pid = 0;
1350
  if (from_tty)
1351
    {
1352
      printf ("Downloading \"%s\" to the ES 1800\n", filename);
1353
    }
1354
  if ((instream = fopen (loadname, "r")) == NULL)
1355
    {
1356
      perror_with_name ("fopen:");
1357
    }
1358
 
1359
  old_chain = make_cleanup (fclose, instream);
1360
  immediate_quit++;
1361
 
1362
  es1800_reset (0);
1363
 
1364
  download (instream, from_tty, es1800_load_format);
1365
 
1366
  /* if breakpoint routine is not present anymore we have to check
1367
     whether to download a new breakpoint routine or not */
1368
 
1369
  if ((verify_break (es1800_break_vec) != 0)
1370
      && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
1371
    {
1372
      char buf[128];
1373
      printf ("Using break vector 0x%x\n", es1800_break_vec);
1374
      sprintf (buf, "0x%x ", es1800_break_vec);
1375
      printf ("Give the start address of the breakpoint routine: ");
1376
      fgets (buf + strlen (buf), sizeof (buf) - strlen (buf), stdin);
1377
      es1800_init_break (buf, 0);
1378
    }
1379
 
1380
  do_cleanups (old_chain);
1381
  expect_prompt ();
1382
  readchar ();                  /* FIXME I am getting a ^G = 7 after the prompt  */
1383
  printf ("\n");
1384
 
1385
  if (fclose (instream) == EOF)
1386
    {
1387
      ;
1388
    }
1389
 
1390
  if (es1800_load_format != 2)
1391
    {
1392
      sprintf (buf, "/usr/bin/rm %s", loadname);
1393
      system (buf);
1394
    }
1395
 
1396
  symbol_file_command (filename, from_tty);     /* reading symbol table */
1397
  immediate_quit--;
1398
}
1399
 
1400
#if 0
1401
 
1402
#define NUMCPYBYTES 20
1403
 
1404
static void
1405
bfd_copy (from_bfd, to_bfd)
1406
     bfd *from_bfd;
1407
     bfd *to_bfd;
1408
{
1409
  asection *p, *new;
1410
  int i;
1411
  char buf[NUMCPYBYTES];
1412
 
1413
  for (p = from_bfd->sections; p != NULL; p = p->next)
1414
    {
1415
      printf ("  Copying section %s. Size = %x.\n", p->name, p->_cooked_size);
1416
      printf ("    vma = %x,  offset = %x,  output_sec = %x\n",
1417
              p->vma, p->output_offset, p->output_section);
1418
      new = bfd_make_section (to_bfd, p->name);
1419
      if (p->_cooked_size &&
1420
          !bfd_set_section_size (to_bfd, new, p->_cooked_size))
1421
        {
1422
          error ("Wrong BFD size!\n");
1423
        }
1424
      if (!bfd_set_section_flags (to_bfd, new, p->flags))
1425
        {
1426
          error ("bfd_set_section_flags");
1427
        }
1428
      new->vma = p->vma;
1429
 
1430
      for (i = 0; (i + NUMCPYBYTES) < p->_cooked_size; i += NUMCPYBYTES)
1431
        {
1432
          if (!bfd_get_section_contents (from_bfd, p, (PTR) buf, (file_ptr) i,
1433
                                         (bfd_size_type) NUMCPYBYTES))
1434
            {
1435
              error ("bfd_get_section_contents\n");
1436
            }
1437
          if (!bfd_set_section_contents (to_bfd, new, (PTR) buf, (file_ptr) i,
1438
                                         (bfd_size_type) NUMCPYBYTES))
1439
            {
1440
              error ("bfd_set_section_contents\n");
1441
            }
1442
        }
1443
      bfd_get_section_contents (from_bfd, p, (PTR) buf, (file_ptr) i,
1444
                                (bfd_size_type) (p->_cooked_size - i));
1445
      bfd_set_section_contents (to_bfd, new, (PTR) buf, (file_ptr) i,
1446
                                (bfd_size_type) (p->_cooked_size - i));
1447
    }
1448
}
1449
 
1450
#endif
1451
 
1452
/* Start an process on the es1800 and set inferior_pid to the new
1453
   process' pid.
1454
   execfile - the file to run
1455
   args     - arguments passed to the program
1456
   env      - the environment vector to pass    */
1457
 
1458
static void
1459
es1800_create_inferior (execfile, args, env)
1460
     char *execfile;
1461
     char *args;
1462
     char **env;
1463
{
1464
  int entry_pt;
1465
  int pid;
1466
#if 0
1467
  struct expression *expr;
1468
  register struct cleanup *old_chain = 0;
1469
  register value val;
1470
#endif
1471
 
1472
  if (args && *args)
1473
    {
1474
      error ("Can't pass arguments to remote ES1800 process");
1475
    }
1476
 
1477
#if 0
1478
  if (query ("Use 'start' as entry point? "))
1479
    {
1480
      expr = parse_c_expression ("start");
1481
      old_chain = make_cleanup (free_current_contents, &expr);
1482
      val = evaluate_expression (expr);
1483
      entry_pt = (val->location).address;
1484
    }
1485
  else
1486
    {
1487
      printf ("Enter the program's entry point (in hexadecimal): ");
1488
      scanf ("%x", &entry_pt);
1489
    }
1490
#endif
1491
 
1492
  if (execfile == 0 || exec_bfd == 0)
1493
    {
1494
      error ("No executable file specified");
1495
    }
1496
 
1497
  entry_pt = (int) bfd_get_start_address (exec_bfd);
1498
 
1499
  pid = 42;
1500
 
1501
  /* Now that we have a child process, make it our target.  */
1502
 
1503
  push_target (&es1800_child_ops);
1504
 
1505
  /* The "process" (board) is already stopped awaiting our commands, and
1506
     the program is already downloaded.  We just set its PC and go.  */
1507
 
1508
  inferior_pid = pid;           /* Needed for wait_for_inferior below */
1509
 
1510
  clear_proceed_status ();
1511
 
1512
  /* Tell wait_for_inferior that we've started a new process.  */
1513
 
1514
  init_wait_for_inferior ();
1515
 
1516
  /* Set up the "saved terminal modes" of the inferior
1517
     based on what modes we are starting it with.  */
1518
 
1519
  target_terminal_init ();
1520
 
1521
  /* Install inferior's terminal modes.  */
1522
 
1523
  target_terminal_inferior ();
1524
 
1525
  /* remote_start (args); */
1526
  /* trap_expected = 0; */
1527
  /* insert_step_breakpoint ();  FIXME, do we need this?  */
1528
 
1529
  /* Let 'er rip... */
1530
  proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
1531
 
1532
}
1533
 
1534
 
1535
/* The process has died, clean up.  */
1536
 
1537
static void
1538
es1800_mourn_inferior ()
1539
{
1540
  remove_breakpoints ();
1541
  unpush_target (&es1800_child_ops);
1542
  generic_mourn_inferior ();    /* Do all the proper things now */
1543
}
1544
 
1545
/* ES1800-protocol specific routines */
1546
 
1547
/* Keep discarding input from the remote system, until STRING is found.
1548
   Let the user break out immediately.
1549
   string - the string to expect
1550
   nowait - break out if string not the emulator's first respond otherwise
1551
   read until string is found (== 0)   */
1552
 
1553
static void
1554
expect (string, nowait)
1555
     char *string;
1556
     int nowait;
1557
{
1558
  char c;
1559
  char *p = string;
1560
 
1561
  immediate_quit++;
1562
  while (1)
1563
    {
1564
      c = readchar ();
1565
      if (isalpha (c))
1566
        {
1567
          c = toupper (c);
1568
        }
1569
      if (c == toupper (*p))
1570
        {
1571
          p++;
1572
          if (*p == '\0')
1573
            {
1574
              immediate_quit--;
1575
              return;
1576
            }
1577
        }
1578
      else if (!nowait)
1579
        {
1580
          p = string;
1581
        }
1582
      else
1583
        {
1584
          printf ("\'%s\' expected\n", string);
1585
          printf ("char %d is %d", p - string, c);
1586
          error ("\n");
1587
        }
1588
    }
1589
}
1590
 
1591
/* Keep discarding input until we see the prompt.  */
1592
 
1593
static void
1594
expect_prompt ()
1595
{
1596
  expect (">", 0);
1597
}
1598
 
1599
 
1600
/* Read one character */
1601
 
1602
#ifdef DEBUG_STDIN
1603
 
1604
/* read from stdin */
1605
 
1606
static int
1607
readchar ()
1608
{
1609
  char buf[1];
1610
 
1611
  buf[0] = '\0';
1612
  printf ("readchar, give one character\n");
1613
  read (0, buf, 1);
1614
 
1615
#if defined (LOG_FILE)
1616
  putc (buf[0] & 0x7f, log_file);
1617
#endif
1618
 
1619
  return (buf[0] & 0x7f);
1620
}
1621
 
1622
#else /* !DEBUG_STDIN */
1623
 
1624
/* Read a character from the remote system, doing all the fancy
1625
   timeout stuff.  */
1626
 
1627
static int
1628
readchar ()
1629
{
1630
  int ch;
1631
 
1632
  ch = SERIAL_READCHAR (es1800_desc, timeout);
1633
 
1634
  /* FIXME: doing an error() here will probably cause trouble, at least if from
1635
     es1800_wait.  */
1636
  if (ch == SERIAL_TIMEOUT)
1637
    error ("Timeout reading from remote system.");
1638
  else if (ch == SERIAL_ERROR)
1639
    perror_with_name ("remote read");
1640
 
1641
#if defined (LOG_FILE)
1642
  putc (ch & 0x7f, log_file);
1643
  fflush (log_file);
1644
#endif
1645
 
1646
  return (ch);
1647
}
1648
 
1649
#endif /* DEBUG_STDIN */
1650
 
1651
 
1652
/* Send a command to the emulator and save the reply.
1653
   Report an error if we get an error reply.
1654
   string - the es1800 command
1655
   buf    - containing the emulator reply on return
1656
   len    - size of buf  */
1657
 
1658
static void
1659
send_with_reply (string, buf, len)
1660
     char *string, *buf;
1661
     int len;
1662
{
1663
  send (string);
1664
  SERIAL_WRITE (es1800_desc, "\r", 1);
1665
 
1666
#ifndef DEBUG_STDIN
1667
  expect (string, 1);
1668
  expect ("\r\n", 0);
1669
#endif
1670
 
1671
  getmessage (buf, len);
1672
}
1673
 
1674
 
1675
/* Send the command in STR to the emulator adding \r. check
1676
   the echo for consistency.
1677
   string - the es1800 command  */
1678
 
1679
static void
1680
send_command (string)
1681
     char *string;
1682
{
1683
  send (string);
1684
  SERIAL_WRITE (es1800_desc, "\r", 1);
1685
 
1686
#ifndef DEBUG_STDIN
1687
  expect (string, 0);
1688
  expect_prompt ();
1689
#endif
1690
 
1691
}
1692
 
1693
/* Send a string
1694
   string - the es1800 command  */
1695
 
1696
static void
1697
send (string)
1698
     char *string;
1699
{
1700
  if (kiodebug)
1701
    {
1702
      fprintf (stderr, "Sending: %s\n", string);
1703
    }
1704
  SERIAL_WRITE (es1800_desc, string, strlen (string));
1705
}
1706
 
1707
 
1708
/* Read a message from the emulator and store it in BUF.
1709
   buf    - containing the emulator reply on return
1710
   len    - size of buf  */
1711
 
1712
static void
1713
getmessage (buf, len)
1714
     char *buf;
1715
     int len;
1716
{
1717
  char *bp;
1718
  int c;
1719
  int prompt_found = 0;
1720
  extern kiodebug;
1721
 
1722
#if defined (LOG_FILE)
1723
  /* This is a convenient place to do this.  The idea is to do it often
1724
     enough that we never lose much data if we terminate abnormally.  */
1725
  fflush (log_file);
1726
#endif
1727
 
1728
  bp = buf;
1729
  c = readchar ();
1730
  do
1731
    {
1732
      if (c)
1733
        {
1734
          if (len-- < 2)        /* char and terminaling NULL */
1735
            {
1736
              error ("input buffer overrun\n");
1737
            }
1738
          *bp++ = c;
1739
        }
1740
      c = readchar ();
1741
      if ((c == '>') && (*(bp - 1) == ' '))
1742
        {
1743
          prompt_found = 1;
1744
        }
1745
    }
1746
  while (!prompt_found);
1747
  *bp = 0;
1748
 
1749
  if (kiodebug)
1750
    {
1751
      fprintf (stderr, "message received :%s\n", buf);
1752
    }
1753
}
1754
 
1755
static void
1756
download (instream, from_tty, format)
1757
     FILE *instream;
1758
     int from_tty;
1759
     int format;
1760
{
1761
  char c;
1762
  char buf[160];
1763
  int i = 0;
1764
 
1765
  send_command ("SET #2,$1A");  /* reset char = ^Z */
1766
  send_command ("SET #3,$11,$13");      /* XON  XOFF */
1767
  if (format == 2)
1768
    {
1769
      send_command ("SET #26,#2");
1770
    }
1771
  else
1772
    {
1773
      send_command ("SET #26,#5");      /* Format=Extended Tekhex */
1774
    }
1775
  send_command ("DFB = $10");
1776
  send_command ("PUR");
1777
  send_command ("CES");
1778
  send ("DNL\r");
1779
  expect ("DNL", 1);
1780
  if (from_tty)
1781
    {
1782
      printf ("    0 records loaded...\r");
1783
    }
1784
  while (fgets (buf, 160, instream))
1785
    {
1786
      send (buf);
1787
      if (from_tty)
1788
        {
1789
          printf ("%5d\b\b\b\b\b", ++i);
1790
          fflush (stdout);
1791
        }
1792
      if ((c = readchar ()) != 006)
1793
        {
1794
          error ("expected ACK");
1795
        }
1796
    }
1797
  if (from_tty)
1798
    {
1799
      printf ("- All");
1800
    }
1801
}
1802
 
1803
/* Additional commands */
1804
 
1805
#if defined (TIOCGETP) && defined (FNDELAY) && defined (EWOULDBLOCK)
1806
#define PROVIDE_TRANSPARENT
1807
#endif
1808
 
1809
#ifdef PROVIDE_TRANSPARENT
1810
/* Talk directly to the emulator
1811
   FIXME, uses busy wait, and is SUNOS (or at least BSD) specific  */
1812
 
1813
/*ARGSUSED */
1814
static void
1815
es1800_transparent (args, from_tty)
1816
     char *args;
1817
     int from_tty;
1818
{
1819
  int console;
1820
  struct sgttyb modebl;
1821
  int fcflag;
1822
  int cc;
1823
  struct sgttyb console_mode_save;
1824
  int console_fc_save;
1825
  int es1800_fc_save;
1826
  int inputcnt = 80;
1827
  char inputbuf[80];
1828
  int consolecnt = 0;
1829
  char consolebuf[80];
1830
  int es1800_cnt = 0;
1831
  char es1800_buf[80];
1832
  int i;
1833
 
1834
  dont_repeat ();
1835
  if (es1800_desc == NULL)
1836
    {
1837
      printf ("No emulator attached, type emulator-command first\n");
1838
      return;
1839
    }
1840
 
1841
  printf ("\n");
1842
  printf ("You are now communicating directly with the ES 1800 emulator.\n");
1843
  printf ("To leave this mode (transparent mode), press ^E.\n");
1844
  printf ("\n");
1845
  printf (" >");
1846
  fflush (stdout);
1847
 
1848
  if ((console = open ("/dev/tty", O_RDWR)) == -1)
1849
    {
1850
      perror_with_name ("/dev/tty:");
1851
    }
1852
 
1853
  if ((fcflag = fcntl (console, F_GETFL, 0)) == -1)
1854
    {
1855
      perror_with_name ("fcntl console");
1856
    }
1857
 
1858
  console_fc_save = fcflag;
1859
  fcflag = fcflag | FNDELAY;
1860
 
1861
  if (fcntl (console, F_SETFL, fcflag) == -1)
1862
    {
1863
      perror_with_name ("fcntl console");
1864
    }
1865
 
1866
  if (ioctl (console, TIOCGETP, &modebl))
1867
    {
1868
      perror_with_name ("ioctl console");
1869
    }
1870
 
1871
  console_mode_save = modebl;
1872
  modebl.sg_flags = RAW;
1873
 
1874
  if (ioctl (console, TIOCSETP, &modebl))
1875
    {
1876
      perror_with_name ("ioctl console");
1877
    }
1878
 
1879
  if ((fcflag = fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_GETFL, 0)) == -1)
1880
    {
1881
      perror_with_name ("fcntl serial");
1882
    }
1883
 
1884
  es1800_fc_save = fcflag;
1885
  fcflag = fcflag | FNDELAY;
1886
 
1887
  if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_SETFL, fcflag) == -1)
1888
    {
1889
      perror_with_name ("fcntl serial");
1890
    }
1891
 
1892
  while (1)
1893
    {
1894
      cc = read (console, inputbuf, inputcnt);
1895
      if (cc != -1)
1896
        {
1897
          if ((*inputbuf & 0x7f) == 0x05)
1898
            {
1899
              break;
1900
            }
1901
          for (i = 0; i < cc;)
1902
            {
1903
              es1800_buf[es1800_cnt++] = inputbuf[i++];
1904
            }
1905
          if ((cc = SERIAL_WRITE (es1800_desc, es1800_buf, es1800_cnt)) == -1)
1906
            {
1907
              perror_with_name ("FEL! write:");
1908
            }
1909
          es1800_cnt -= cc;
1910
          if (es1800_cnt && cc)
1911
            {
1912
              for (i = 0; i < es1800_cnt; i++)
1913
                {
1914
                  es1800_buf[i] = es1800_buf[cc + i];
1915
                }
1916
            }
1917
        }
1918
      else if (errno != EWOULDBLOCK)
1919
        {
1920
          perror_with_name ("FEL! read:");
1921
        }
1922
 
1923
      cc = read (DEPRECATED_SERIAL_FD (es1800_desc), inputbuf, inputcnt);
1924
      if (cc != -1)
1925
        {
1926
          for (i = 0; i < cc;)
1927
            {
1928
              consolebuf[consolecnt++] = inputbuf[i++];
1929
            }
1930
          if ((cc = write (console, consolebuf, consolecnt)) == -1)
1931
            {
1932
              perror_with_name ("FEL! write:");
1933
            }
1934
          consolecnt -= cc;
1935
          if (consolecnt && cc)
1936
            {
1937
              for (i = 0; i < consolecnt; i++)
1938
                {
1939
                  consolebuf[i] = consolebuf[cc + i];
1940
                }
1941
            }
1942
        }
1943
      else if (errno != EWOULDBLOCK)
1944
        {
1945
          perror_with_name ("FEL! read:");
1946
        }
1947
    }
1948
 
1949
  console_fc_save = console_fc_save & !FNDELAY;
1950
  if (fcntl (console, F_SETFL, console_fc_save) == -1)
1951
    {
1952
      perror_with_name ("FEL! fcntl");
1953
    }
1954
 
1955
  if (ioctl (console, TIOCSETP, &console_mode_save))
1956
    {
1957
      perror_with_name ("FEL! ioctl");
1958
    }
1959
 
1960
  close (console);
1961
 
1962
  if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc), F_SETFL, es1800_fc_save) == -1)
1963
    {
1964
      perror_with_name ("FEL! fcntl");
1965
    }
1966
 
1967
  printf ("\n");
1968
 
1969
}
1970
#endif /* PROVIDE_TRANSPARENT */
1971
 
1972
static void
1973
es1800_init_break (args, from_tty)
1974
     char *args;
1975
     int from_tty;
1976
{
1977
  CORE_ADDR memaddress = 0;
1978
  char buf[PBUFSIZ];
1979
  char base_addr[4];
1980
  char *space_index;
1981
  char *p;
1982
  int k;
1983
 
1984
  if (args == NULL)
1985
    {
1986
      error_no_arg ("a trap vector");
1987
    }
1988
 
1989
  if (!(space_index = strchr (args, ' ')))
1990
    {
1991
      error ("Two arguments needed (trap vector and address of break routine).\n");
1992
    }
1993
 
1994
  *space_index = '\0';
1995
 
1996
  es1800_break_vec = strtol (args, (char **) NULL, 0);
1997
  es1800_break_address = parse_and_eval_address (space_index + 1);
1998
 
1999
  es1800_create_break_insn (es1800_break_insn, es1800_break_vec);
2000
 
2001
  if (m68020)
2002
    {
2003
      send_with_reply ("VBR ", buf, sizeof (buf));
2004
      p = buf;
2005
      for (k = 0; k < 4; k++)
2006
        {
2007
          if ((p[k * 2 + 1] == 0) || (p[k * 2 + 2] == 0))
2008
            {
2009
              error ("Emulator reply is too short: %s", buf);
2010
            }
2011
          base_addr[k] = (fromhex (p[k * 2 + 1]) * 16) + fromhex (p[k * 2 + 2]);
2012
        }
2013
      /* base addr of exception vector table */
2014
      memaddress = *((CORE_ADDR *) base_addr);
2015
    }
2016
 
2017
  memaddress += (es1800_break_vec + 32) * 4;    /* address of trap vector */
2018
 
2019
  sprintf (buf, "@.L%lx=$%lx", memaddress, es1800_break_address);
2020
  send_command (buf);           /* set the address of the break routine in the */
2021
  /* trap vector */
2022
 
2023
  sprintf (buf, "@.L%lx=$4E714E71", es1800_break_address);      /* NOP; NOP */
2024
  send_command (buf);
2025
  sprintf (buf, "@.L%lx=$4E714E73", es1800_break_address + 4);  /* NOP; RTE */
2026
  send_command (buf);
2027
 
2028
  sprintf (buf, "AC2=$%lx", es1800_break_address + 4);
2029
  /* breakpoint at es1800-break_address */
2030
  send_command (buf);
2031
  send_command ("WHEN AC2 THEN BRK");   /* ie in exception routine */
2032
 
2033
  if (from_tty)
2034
    {
2035
      printf ("Breakpoint (trap $%x) routine at address: %lx\n",
2036
              es1800_break_vec, es1800_break_address);
2037
    }
2038
}
2039
 
2040
static void
2041
es1800_child_open (arg, from_tty)
2042
     char *arg;
2043
     int from_tty;
2044
{
2045
  error ("Use the \"run\" command to start a child process.");
2046
}
2047
 
2048
static void
2049
es1800_child_detach (args, from_tty)
2050
     char *args;
2051
     int from_tty;
2052
{
2053
  if (args)
2054
    {
2055
      error ("Argument given to \"detach\" when remotely debugging.");
2056
    }
2057
 
2058
  pop_target ();
2059
  if (from_tty)
2060
    {
2061
      printf ("Ending debugging the process %d.\n", inferior_pid);
2062
    }
2063
}
2064
 
2065
 
2066
/* Define the target subroutine names  */
2067
 
2068
struct target_ops es1800_ops;
2069
 
2070
static void
2071
init_es1800_ops (void)
2072
{
2073
  es1800_ops.to_shortname = "es1800";
2074
  es1800_ops.to_longname = "Remote serial target in ES1800-emulator protocol";
2075
  es1800_ops.to_doc = "Remote debugging on the es1800 emulator via a serial line.\n\
2076
Specify the serial device it is connected to (e.g. /dev/ttya).";
2077
  es1800_ops.to_open = es1800_open;
2078
  es1800_ops.to_close = es1800_close;
2079
  es1800_ops.to_attach = es1800_attach;
2080
  es1800_ops.to_post_attach = NULL;
2081
  es1800_ops.to_require_attach = NULL;
2082
  es1800_ops.to_detach = es1800_detach;
2083
  es1800_ops.to_require_detach = NULL;
2084
  es1800_ops.to_resume = es1800_resume;
2085
  es1800_ops.to_wait = NULL;
2086
  es1800_ops.to_post_wait = NULL;
2087
  es1800_ops.to_fetch_registers = NULL;
2088
  es1800_ops.to_store_registers = NULL;
2089
  es1800_ops.to_prepare_to_store = es1800_prepare_to_store;
2090
  es1800_ops.to_xfer_memory = es1800_xfer_inferior_memory;
2091
  es1800_ops.to_files_info = es1800_files_info;
2092
  es1800_ops.to_insert_breakpoint = es1800_insert_breakpoint;
2093
  es1800_ops.to_remove_breakpoint = es1800_remove_breakpoint;
2094
  es1800_ops.to_terminal_init = NULL;
2095
  es1800_ops.to_terminal_inferior = NULL;
2096
  es1800_ops.to_terminal_ours_for_output = NULL;
2097
  es1800_ops.to_terminal_ours = NULL;
2098
  es1800_ops.to_terminal_info = NULL;
2099
  es1800_ops.to_kill = NULL;
2100
  es1800_ops.to_load = es1800_load;
2101
  es1800_ops.to_lookup_symbol = NULL;
2102
  es1800_ops.to_create_inferior = es1800_create_inferior;
2103
  es1800_ops.to_post_startup_inferior = NULL;
2104
  es1800_ops.to_acknowledge_created_inferior = NULL;
2105
  es1800_ops.to_clone_and_follow_inferior = NULL;
2106
  es1800_ops.to_post_follow_inferior_by_clone = NULL;
2107
  es1800_ops.to_insert_fork_catchpoint = NULL;
2108
  es1800_ops.to_remove_fork_catchpoint = NULL;
2109
  es1800_ops.to_insert_vfork_catchpoint = NULL;
2110
  es1800_ops.to_remove_vfork_catchpoint = NULL;
2111
  es1800_ops.to_has_forked = NULL;
2112
  es1800_ops.to_has_vforked = NULL;
2113
  es1800_ops.to_can_follow_vfork_prior_to_exec = NULL;
2114
  es1800_ops.to_post_follow_vfork = NULL;
2115
  es1800_ops.to_insert_exec_catchpoint = NULL;
2116
  es1800_ops.to_remove_exec_catchpoint = NULL;
2117
  es1800_ops.to_has_execd = NULL;
2118
  es1800_ops.to_reported_exec_events_per_exec_call = NULL;
2119
  es1800_ops.to_has_exited = NULL;
2120
  es1800_ops.to_mourn_inferior = NULL;
2121
  es1800_ops.to_can_run = 0;
2122
  es1800_ops.to_notice_signals = 0;
2123
  es1800_ops.to_thread_alive = 0;
2124
  es1800_ops.to_stop = 0;
2125
  es1800_ops.to_pid_to_exec_file = NULL;
2126
  es1800_ops.to_core_file_to_sym_file = NULL;
2127
  es1800_ops.to_stratum = core_stratum;
2128
  es1800_ops.DONT_USE = 0;
2129
  es1800_ops.to_has_all_memory = 0;
2130
  es1800_ops.to_has_memory = 1;
2131
  es1800_ops.to_has_stack = 0;
2132
  es1800_ops.to_has_registers = 0;
2133
  es1800_ops.to_has_execution = 0;
2134
  es1800_ops.to_sections = NULL;
2135
  es1800_ops.to_sections_end = NULL;
2136
  es1800_ops.to_magic = OPS_MAGIC;
2137
}
2138
 
2139
/* Define the target subroutine names  */
2140
 
2141
struct target_ops es1800_child_ops;
2142
 
2143
static void
2144
init_es1800_child_ops (void)
2145
{
2146
  es1800_child_ops.to_shortname = "es1800_process";
2147
  es1800_child_ops.to_longname = "Remote serial target in ES1800-emulator protocol";
2148
  es1800_child_ops.to_doc = "Remote debugging on the es1800 emulator via a serial line.\n\
2149
Specify the serial device it is connected to (e.g. /dev/ttya).";
2150
  es1800_child_ops.to_open = es1800_child_open;
2151
  es1800_child_ops.to_close = NULL;
2152
  es1800_child_ops.to_attach = es1800_attach;
2153
  es1800_child_ops.to_post_attach = NULL;
2154
  es1800_child_ops.to_require_attach = NULL;
2155
  es1800_child_ops.to_detach = es1800_child_detach;
2156
  es1800_child_ops.to_require_detach = NULL;
2157
  es1800_child_ops.to_resume = es1800_resume;
2158
  es1800_child_ops.to_wait = es1800_wait;
2159
  es1800_child_ops.to_post_wait = NULL;
2160
  es1800_child_ops.to_fetch_registers = es1800_fetch_register;
2161
  es1800_child_ops.to_store_registers = es1800_store_register;
2162
  es1800_child_ops.to_prepare_to_store = es1800_prepare_to_store;
2163
  es1800_child_ops.to_xfer_memory = es1800_xfer_inferior_memory;
2164
  es1800_child_ops.to_files_info = es1800_files_info;
2165
  es1800_child_ops.to_insert_breakpoint = es1800_insert_breakpoint;
2166
  es1800_child_ops.to_remove_breakpoint = es1800_remove_breakpoint;
2167
  es1800_child_ops.to_terminal_init = NULL;
2168
  es1800_child_ops.to_terminal_inferior = NULL;
2169
  es1800_child_ops.to_terminal_ours_for_output = NULL;
2170
  es1800_child_ops.to_terminal_ours = NULL;
2171
  es1800_child_ops.to_terminal_info = NULL;
2172
  es1800_child_ops.to_kill = es1800_kill;
2173
  es1800_child_ops.to_load = es1800_load;
2174
  es1800_child_ops.to_lookup_symbol = NULL;
2175
  es1800_child_ops.to_create_inferior = es1800_create_inferior;
2176
  es1800_child_ops.to_post_startup_inferior = NULL;
2177
  es1800_child_ops.to_acknowledge_created_inferior = NULL;
2178
  es1800_child_ops.to_clone_and_follow_inferior = NULL;
2179
  es1800_child_ops.to_post_follow_inferior_by_clone = NULL;
2180
  es1800_child_ops.to_insert_fork_catchpoint = NULL;
2181
  es1800_child_ops.to_remove_fork_catchpoint = NULL;
2182
  es1800_child_ops.to_insert_vfork_catchpoint = NULL;
2183
  es1800_child_ops.to_remove_vfork_catchpoint = NULL;
2184
  es1800_child_ops.to_has_forked = NULL;
2185
  es1800_child_ops.to_has_vforked = NULL;
2186
  es1800_child_ops.to_can_follow_vfork_prior_to_exec = NULL;
2187
  es1800_child_ops.to_post_follow_vfork = NULL;
2188
  es1800_child_ops.to_insert_exec_catchpoint = NULL;
2189
  es1800_child_ops.to_remove_exec_catchpoint = NULL;
2190
  es1800_child_ops.to_has_execd = NULL;
2191
  es1800_child_ops.to_reported_exec_events_per_exec_call = NULL;
2192
  es1800_child_ops.to_has_exited = NULL;
2193
  es1800_child_ops.to_mourn_inferior = es1800_mourn_inferior;
2194
  es1800_child_ops.to_can_run = 0;
2195
  es1800_child_ops.to_notice_signals = 0;
2196
  es1800_child_ops.to_thread_alive = 0;
2197
  es1800_child_ops.to_stop = 0;
2198
  es1800_child_ops.to_pid_to_exec_file = NULL;
2199
  es1800_child_ops.to_core_file_to_sym_file = NULL;
2200
  es1800_child_ops.to_stratum = process_stratum;
2201
  es1800_child_ops.DONT_USE = 0;
2202
  es1800_child_ops.to_has_all_memory = 1;
2203
  es1800_child_ops.to_has_memory = 1;
2204
  es1800_child_ops.to_has_stack = 1;
2205
  es1800_child_ops.to_has_registers = 1;
2206
  es1800_child_ops.to_has_execution = 1;
2207
  es1800_child_ops.to_sections = NULL;
2208
  es1800_child_ops.to_sections_end = NULL;
2209
  es1800_child_ops.to_magic = OPS_MAGIC;
2210
}
2211
 
2212
void
2213
_initialize_es1800 ()
2214
{
2215
  init_es1800_ops ();
2216
  init_es1800_child_ops ();
2217
  add_target (&es1800_ops);
2218
  add_target (&es1800_child_ops);
2219
#ifdef PROVIDE_TRANSPARENT
2220
  add_com ("transparent", class_support, es1800_transparent,
2221
           "Start transparent communication with the ES 1800 emulator.");
2222
#endif /* PROVIDE_TRANSPARENT */
2223
  add_com ("init_break", class_support, es1800_init_break,
2224
         "Download break routine and initialize break facility on ES 1800");
2225
}

powered by: WebSVN 2.1.0

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