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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [sim/] [arm/] [kid.c] - Blame information for rev 301

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/*  kid.c -- ARMulator RDP/RDI interface:  ARM6 Instruction Emulator.
2
    Copyright (C) 1994 Advanced RISC Machines Ltd.
3
 
4
    This program is free software; you can redistribute it and/or modify
5
    it under the terms of the GNU General Public License as published by
6
    the Free Software Foundation; either version 2 of the License, or
7
    (at your option) any later version.
8
 
9
    This program is distributed in the hope that it will be useful,
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
    GNU General Public License for more details.
13
 
14
    You should have received a copy of the GNU General Public License
15
    along with this program; if not, write to the Free Software
16
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
17
 
18
/*****************************************************************/
19
/* The child process continues here...                           */
20
/* It waits on a pipe from the parent and translates the RDP     */
21
/* messages into RDI calls to the ARMulator passing RDP replies  */
22
/* back up a pipe to the parent.                                 */
23
/*****************************************************************/
24
 
25
#include <sys/types.h>
26
#include <signal.h>
27
 
28
#include "armdefs.h"
29
#include "dbg_conf.h"
30
#include "dbg_hif.h"
31
#include "dbg_rdi.h"
32
#include "gdbhost.h"
33
#include "communicate.h"
34
 
35
/* The pipes between the two processes */
36
extern int mumkid[2];
37
extern int kidmum[2];
38
 
39
/* The maximum number of file descriptors */
40
extern int nfds;
41
 
42
/* The machine name */
43
#define MAXHOSTNAMELENGTH 64
44
extern char localhost[MAXHOSTNAMELENGTH + 1];
45
 
46
/* The socket number */
47
extern unsigned int socketnumber;
48
 
49
/* RDI interface */
50
extern const struct RDIProcVec armul_rdi;
51
 
52
static int MYrdp_level = 0;
53
 
54
static int rdi_state = 0;
55
 
56
/**************************************************************/
57
/* Signal handler that terminates excecution in the ARMulator */
58
/**************************************************************/
59
void
60
kid_handlesignal (int sig)
61
{
62
#ifdef DEBUG
63
  fprintf (stderr, "Terminate ARMulator excecution\n");
64
#endif
65
  if (sig != SIGUSR1)
66
    {
67
      fprintf (stderr, "Unsupported signal.\n");
68
      return;
69
    }
70
  armul_rdi.info (RDISignal_Stop, (unsigned long *) 0, (unsigned long *) 0);
71
}
72
 
73
/********************************************************************/
74
/* Waits on a pipe from the socket demon for RDP and                */
75
/* acts as an RDP to RDI interpreter on the front of the ARMulator. */
76
/********************************************************************/
77
void
78
kid ()
79
{
80
  char *p, *q;
81
  int i, j, k;
82
  long outofthebag;
83
  unsigned char c, d, message;
84
  ARMword x, y, z;
85
  struct sigaction action;
86
  PointHandle point;
87
  Dbg_ConfigBlock config;
88
  Dbg_HostosInterface hostif;
89
  struct Dbg_MCState *MCState;
90
  char command_line[256];
91
  struct fd_set readfds;
92
 
93
  /* Setup a signal handler for SIGUSR1 */
94
  action.sa_handler = kid_handlesignal;
95
  action.sa_mask = 0;
96
  action.sa_flags = 0;
97
 
98
  sigaction (SIGUSR1, &action, (struct sigaction *) 0);
99
 
100
  while (1)
101
    {
102
      /* Wait for ever */
103
      FD_ZERO (&readfds);
104
      FD_SET (mumkid[0], &readfds);
105
 
106
      i = select (nfds, &readfds,
107
                  (fd_set *) 0, (fd_set *) 0, (struct timeval *) 0);
108
 
109
      if (i < 0)
110
        {
111
          perror ("select");
112
        }
113
 
114
      if (read (mumkid[0], &message, 1) < 1)
115
        {
116
          perror ("read");
117
        }
118
 
119
      switch (message)
120
        {
121
        case RDP_Start:
122
          /* Open and/or Initialise */
123
          BAG_newbag ();
124
 
125
          MYread_char (mumkid[0], &c);   /* type */
126
          MYread_word (mumkid[0], &x);   /* memorysize */
127
          if (c & 0x2)
128
            MYread_char (mumkid[0], &d); /* speed */
129
          config.processor = 0;
130
          config.memorysize = x;
131
          config.bytesex = (c & 0x4) ? RDISex_Big : RDISex_Little;
132
          if (c & 0x8)
133
            config.bytesex = RDISex_DontCare;
134
 
135
          hostif.dbgprint = myprint;
136
          hostif.dbgpause = mypause;
137
          hostif.dbgarg = stdout;
138
          hostif.writec = mywritec;
139
          hostif.readc = myreadc;
140
          hostif.write = mywrite;
141
          hostif.gets = mygets;
142
          hostif.reset = mypause;       /* do nothing */
143
          hostif.resetarg = "Do I love resetting or what!\n";
144
 
145
          if (rdi_state)
146
            {
147
              /* we have restarted, so kill off the existing run.  */
148
              /* armul_rdi.close(); */
149
            }
150
          i = armul_rdi.open (c & 0x3, &config, &hostif, MCState);
151
          rdi_state = 1;
152
 
153
          MYwrite_char (kidmum[1], RDP_Return);
154
          MYwrite_char (kidmum[1], (unsigned char) i);
155
 
156
          x = ~0x4;
157
          armul_rdi.info (RDIVector_Catch, &x, 0);
158
 
159
          break;
160
 
161
        case RDP_End:
162
          /* Close and Finalise */
163
          i = armul_rdi.close ();
164
          rdi_state = 0;
165
          MYwrite_char (kidmum[1], RDP_Return);
166
          MYwrite_char (kidmum[1], (unsigned char) i);
167
          break;
168
 
169
        case RDP_Read:
170
          /* Read Memory Address */
171
          MYread_word (mumkid[0], &x);   /* address */
172
          MYread_word (mumkid[0], &y);   /* nbytes */
173
          p = (char *) malloc (y);
174
          i = armul_rdi.read (x, p, (unsigned *) &y);
175
          MYwrite_char (kidmum[1], RDP_Return);
176
          for (k = 0; k < y; k++)
177
            MYwrite_char (kidmum[1], p[k]);
178
          free (p);
179
          MYwrite_char (kidmum[1], (unsigned char) i);
180
          if (i)
181
            MYwrite_word (kidmum[1], y);        /* number of bytes sent without error */
182
          break;
183
 
184
        case RDP_Write:
185
          /* Write Memory Address */
186
          MYread_word (mumkid[0], &x);   /* address */
187
          MYread_word (mumkid[0], &y);   /* nbytes */
188
          p = (char *) malloc (y);
189
          for (k = 0; k < y; k++)
190
            MYread_char (mumkid[0], &p[k]);
191
          i = armul_rdi.write (p, x, (unsigned *) &y);
192
          free (p);
193
          MYwrite_char (kidmum[1], RDP_Return);
194
          MYwrite_char (kidmum[1], (unsigned char) i);
195
          if (i)
196
            MYwrite_word (kidmum[1], y);        /* number of bytes sent without error */
197
          break;
198
 
199
        case RDP_CPUread:
200
          /* Read CPU State */
201
          MYread_char (mumkid[0], &c);   /* mode */
202
          MYread_word (mumkid[0], &x);   /* mask */
203
          p = (char *) malloc (4 * RDINumCPURegs);
204
          i = armul_rdi.CPUread (c, x, (ARMword *) p);
205
          MYwrite_char (kidmum[1], RDP_Return);
206
          for (k = 1, j = 0; k != 0x80000000; k *= 2)
207
            if (k & x)
208
              MYwrite_word (kidmum[1], ((ARMword *) p)[j++]);
209
          free (p);
210
          if (i)
211
            MYwrite_char (kidmum[1], (unsigned char) j);
212
          MYwrite_char (kidmum[1], (unsigned char) i);
213
          break;
214
 
215
        case RDP_CPUwrite:
216
          /* Write CPU State */
217
          MYread_char (mumkid[0], &c);   /* mode */
218
          MYread_word (mumkid[0], &x);   /* mask */
219
 
220
          p = (char *) malloc (4 * RDINumCPURegs);
221
          for (k = 1, j = 0; k != 0x80000000; k *= 2)
222
            if (k & x)
223
              MYread_word (mumkid[0], &(((ARMword *) p)[j++]));
224
          i = armul_rdi.CPUwrite (c, x, (ARMword *) p);
225
          MYwrite_char (kidmum[1], RDP_Return);
226
          MYwrite_char (kidmum[1], (unsigned char) i);
227
          free (p);
228
          break;
229
 
230
        case RDP_CPread:
231
          /* Read Co-Processor State */
232
          MYread_char (mumkid[0], &c);   /* CPnum */
233
          MYread_word (mumkid[0], &x);   /* mask */
234
          p = q = (char *) malloc (16 * RDINumCPRegs);
235
          i = armul_rdi.CPread (c, x, (ARMword *) p);
236
          MYwrite_char (kidmum[1], RDP_Return);
237
          for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
238
            if (k & x)
239
              {
240
                if ((c == 1 || c == 2) && k <= 128)
241
                  {
242
                    MYwrite_FPword (kidmum[1], q);
243
                    q += 16;
244
                  }
245
                else
246
                  {
247
                    MYwrite_word (kidmum[1], *q);
248
                    q += 4;
249
                  }
250
              }
251
          free (p);
252
          if (i)
253
            MYwrite_char (kidmum[1], (unsigned char) j);
254
          MYwrite_char (kidmum[1], (unsigned char) i);
255
          break;
256
 
257
        case RDP_CPwrite:
258
          /* Write Co-Processor State */
259
          MYread_char (mumkid[0], &c);   /* CPnum */
260
          MYread_word (mumkid[0], &x);   /* mask */
261
          p = q = (char *) malloc (16 * RDINumCPURegs);
262
          for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
263
            if (k & x)
264
              {
265
                if ((c == 1 || c == 2) && k <= 128)
266
                  {
267
                    MYread_FPword (kidmum[1], q);
268
                    q += 16;
269
                  }
270
                else
271
                  {
272
                    MYread_word (mumkid[0], (ARMword *) q);
273
                    q += 4;
274
                  }
275
              }
276
          i = armul_rdi.CPwrite (c, x, (ARMword *) p);
277
          MYwrite_char (kidmum[1], RDP_Return);
278
          MYwrite_char (kidmum[1], (unsigned char) i);
279
          free (p);
280
          break;
281
 
282
        case RDP_SetBreak:
283
          /* Set Breakpoint */
284
          MYread_word (mumkid[0], &x);   /* address */
285
          MYread_char (mumkid[0], &c);   /* type */
286
          if ((c & 0xf) >= 5)
287
            MYread_word (mumkid[0], &y); /* bound */
288
          i = armul_rdi.setbreak (x, c, y, &point);
289
          if (!MYrdp_level)
290
            BAG_putpair ((long) x, (long) point);
291
          MYwrite_char (kidmum[1], RDP_Return);
292
          if (MYrdp_level)
293
            MYwrite_word (kidmum[1], point);
294
          MYwrite_char (kidmum[1], (unsigned char) i);
295
          break;
296
 
297
        case RDP_ClearBreak:
298
          /* Clear Breakpoint */
299
          MYread_word (mumkid[0], &point);       /* PointHandle */
300
          if (!MYrdp_level)
301
            {
302
              BAG_getsecond ((long) point, &outofthebag);       /* swap pointhandle for address */
303
              BAG_killpair_byfirst (outofthebag);
304
              point = outofthebag;
305
            }
306
          i = armul_rdi.clearbreak (point);
307
          MYwrite_char (kidmum[1], RDP_Return);
308
          MYwrite_char (kidmum[1], (unsigned char) i);
309
          break;
310
 
311
        case RDP_SetWatch:
312
          /* Set Watchpoint */
313
          MYread_word (mumkid[0], &x);   /* address */
314
          MYread_char (mumkid[0], &c);   /* type */
315
          MYread_char (mumkid[0], &d);   /* datatype */
316
          if ((c & 0xf) >= 5)
317
            MYread_word (mumkid[0], &y); /* bound */
318
          i = armul_rdi.setwatch (x, c, d, y, &point);
319
          MYwrite_char (kidmum[1], RDP_Return);
320
          MYwrite_word (kidmum[1], point);
321
          MYwrite_char (kidmum[1], (unsigned char) i);
322
          break;
323
 
324
        case RDP_ClearWatch:
325
          /* Clear Watchpoint */
326
          MYread_word (mumkid[0], &point);       /* PointHandle */
327
          i = armul_rdi.clearwatch (point);
328
          MYwrite_char (kidmum[1], RDP_Return);
329
          MYwrite_char (kidmum[1], (unsigned char) i);
330
          break;
331
 
332
        case RDP_Execute:
333
          /* Excecute */
334
 
335
          MYread_char (mumkid[0], &c);   /* return */
336
 
337
#ifdef DEBUG
338
          fprintf (stderr, "Starting execution\n");
339
#endif
340
          i = armul_rdi.execute (&point);
341
#ifdef DEBUG
342
          fprintf (stderr, "Completed execution\n");
343
#endif
344
          MYwrite_char (kidmum[1], RDP_Return);
345
          if (c & 0x80)
346
            MYwrite_word (kidmum[1], point);
347
          MYwrite_char (kidmum[1], (unsigned char) i);
348
          break;
349
 
350
        case RDP_Step:
351
          /* Step */
352
          MYread_char (mumkid[0], &c);   /* return */
353
          MYread_word (mumkid[0], &x);   /* ninstr */
354
          point = 0x87654321;
355
          i = armul_rdi.step (x, &point);
356
          MYwrite_char (kidmum[1], RDP_Return);
357
          if (c & 0x80)
358
            MYwrite_word (kidmum[1], point);
359
          MYwrite_char (kidmum[1], (unsigned char) i);
360
          break;
361
 
362
        case RDP_Info:
363
          /* Info */
364
          MYread_word (mumkid[0], &x);
365
          switch (x)
366
            {
367
            case RDIInfo_Target:
368
              i = armul_rdi.info (RDIInfo_Target, &y, &z);
369
              MYwrite_char (kidmum[1], RDP_Return);
370
              MYwrite_word (kidmum[1], y);      /* Loads of info... */
371
              MYwrite_word (kidmum[1], z);      /* Model */
372
              MYwrite_char (kidmum[1], (unsigned char) i);
373
              break;
374
 
375
            case RDISet_RDILevel:
376
              MYread_word (mumkid[0], &x);       /* arg1, debug level */
377
              i = armul_rdi.info (RDISet_RDILevel, &x, 0);
378
              if (i == RDIError_NoError)
379
                MYrdp_level = x;
380
              MYwrite_char (kidmum[1], RDP_Return);
381
              MYwrite_char (kidmum[1], (unsigned char) i);
382
              break;
383
 
384
            case RDISet_Cmdline:
385
              for (p = command_line; MYread_char (mumkid[0], p), *p; p++)
386
                ;               /* String */
387
              i = armul_rdi.info (RDISet_Cmdline,
388
                                  (unsigned long *) command_line, 0);
389
              MYwrite_char (kidmum[1], RDP_Return);
390
              MYwrite_char (kidmum[1], (unsigned char) i);
391
              break;
392
 
393
            case RDIInfo_Step:
394
              i = armul_rdi.info (RDIInfo_Step, &x, 0);
395
              MYwrite_char (kidmum[1], RDP_Return);
396
              MYwrite_word (kidmum[1], x);
397
              MYwrite_char (kidmum[1], (unsigned char) i);
398
              break;
399
 
400
            case RDIVector_Catch:
401
              MYread_word (mumkid[0], &x);
402
              i = armul_rdi.info (RDIVector_Catch, &x, 0);
403
              MYwrite_char (kidmum[1], RDP_Return);
404
              MYwrite_char (kidmum[1], i);
405
              break;
406
 
407
            case RDIInfo_Points:
408
              i = armul_rdi.info (RDIInfo_Points, &x, 0);
409
              MYwrite_char (kidmum[1], RDP_Return);
410
              MYwrite_word (kidmum[1], x);
411
              MYwrite_char (kidmum[1], (unsigned char) i);
412
              break;
413
 
414
            default:
415
              fprintf (stderr, "Unsupported info code %d\n", x);
416
              break;
417
            }
418
          break;
419
 
420
        case RDP_OSOpReply:
421
          /* OS Operation Reply */
422
          MYwrite_char (kidmum[1], RDP_Fatal);
423
          break;
424
 
425
        case RDP_Reset:
426
          /* Reset */
427
          for (i = 0; i < 50; i++)
428
            MYwrite_char (kidmum[1], RDP_Reset);
429
          p = (char *) malloc (MAXHOSTNAMELENGTH + 5 + 20);
430
          sprintf (p, "Running on %s:%d\n", localhost, socketnumber);
431
          MYwrite_string (kidmum[1], p);
432
          free (p);
433
 
434
          break;
435
        default:
436
          fprintf (stderr, "Oh dear: Something is seriously wrong :-(\n");
437
          /* Hmm.. bad RDP operation */
438
          break;
439
        }
440
    }
441
}
442
 
443
 
444
/* Handles memory read operations until an OS Operation Reply Message is */
445
/* encounterd. It then returns the byte info value (0, 1, or 2) and fills  */
446
/* in 'putinr0' with the data if appropriate. */
447
int
448
wait_for_osreply (ARMword * reply)
449
{
450
  char *p, *q;
451
  int i, j, k;
452
  unsigned char c, d, message;
453
  ARMword x, y, z;
454
  struct sigaction action;
455
  PointHandle point;
456
  Dbg_ConfigBlock config;
457
  Dbg_HostosInterface hostif;
458
  struct Dbg_MCState *MCState;
459
  char command_line[256];
460
  struct fd_set readfds;
461
 
462
#ifdef DEBUG
463
  fprintf (stderr, "wait_for_osreply ().\n");
464
#endif
465
 
466
  /* Setup a signal handler for SIGUSR1 */
467
  action.sa_handler = kid_handlesignal;
468
  action.sa_mask = 0;
469
  action.sa_flags = 0;
470
 
471
  sigaction (SIGUSR1, &action, (struct sigaction *) 0);
472
 
473
  while (1)
474
    {
475
      /* Wait for ever */
476
      FD_ZERO (&readfds);
477
      FD_SET (mumkid[0], &readfds);
478
 
479
      i = select (nfds, &readfds,
480
                  (fd_set *) 0, (fd_set *) 0, (struct timeval *) 0);
481
 
482
      if (i < 0)
483
        {
484
          perror ("select");
485
        }
486
 
487
      if (read (mumkid[0], &message, 1) < 1)
488
        {
489
          perror ("read");
490
        }
491
 
492
      switch (message)
493
        {
494
        case RDP_Read:
495
          /* Read Memory Address */
496
          MYread_word (mumkid[0], &x);   /* address */
497
          MYread_word (mumkid[0], &y);   /* nbytes */
498
          p = (char *) malloc (y);
499
          i = armul_rdi.read (x, p, (unsigned *) &y);
500
          MYwrite_char (kidmum[1], RDP_Return);
501
          for (k = 0; k < y; k++)
502
            MYwrite_char (kidmum[1], p[k]);
503
          free (p);
504
          MYwrite_char (kidmum[1], (unsigned char) i);
505
          if (i)
506
            MYwrite_word (kidmum[1], y);        /* number of bytes sent without error */
507
          break;
508
 
509
        case RDP_Write:
510
          /* Write Memory Address */
511
          MYread_word (mumkid[0], &x);   /* address */
512
          MYread_word (mumkid[0], &y);   /* nbytes */
513
          p = (char *) malloc (y);
514
          for (k = 0; k < y; k++)
515
            MYread_char (mumkid[0], &p[k]);
516
          i = armul_rdi.write (p, x, (unsigned *) &y);
517
          free (p);
518
          MYwrite_char (kidmum[1], RDP_Return);
519
          MYwrite_char (kidmum[1], (unsigned char) i);
520
          if (i)
521
            MYwrite_word (kidmum[1], y);        /* number of bytes sent without error */
522
          break;
523
 
524
        case RDP_OSOpReply:
525
          /* OS Operation Reply */
526
          MYread_char (mumkid[0], &c);
527
          if (c == 1)
528
            MYread_char (mumkid[0], (char *) reply);
529
          if (c == 2)
530
            MYread_word (mumkid[0], reply);
531
          return c;
532
          break;
533
 
534
        default:
535
          fprintf (stderr,
536
                   "HELP! Unaccounted-for message during OS request. \n");
537
          MYwrite_char (kidmum[1], RDP_Fatal);
538
        }
539
    }
540
}

powered by: WebSVN 2.1.0

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