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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [sim/] [arm/] [parent.c] - Blame information for rev 856

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

Line No. Rev Author Line
1 24 jeremybenn
/*  parent.c -- ARMulator RDP comms code:  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 Parent process continues here...                          */
20
/* It waits on the socket and passes on RDP messages down a pipe */
21
/* to the ARMulator RDP to RDI interpreter.                      */
22
/*****************************************************************/
23
 
24
#include <stdio.h>
25
#include <sys/types.h>
26
#include <signal.h>
27
#include "time.h"
28
#include "armdefs.h"
29
#include "dbg_rdi.h"
30
#include "communicate.h"
31
 
32
/* The socket to the debugger */
33
extern int debugsock;
34
 
35
/* The pipes between the two processes */
36
extern int mumkid[2];
37
extern int kidmum[2];
38
 
39
/* A pipe for handling SWI return values that goes straight from the */
40
/* parent to the ARMulator host interface, bypassing the child's RDP */
41
/* to RDI interpreter */
42
extern int DebuggerARMul[2];
43
 
44
/* The maximum number of file descriptors */
45
extern int nfds;
46
 
47
/* The child process id. */
48
extern pid_t child;
49
 
50
void
51
parent ()
52
{
53
  int i, j, k;
54
  unsigned char message, CPnum, exreturn;
55
  ARMword mask, nbytes, messagetype;
56
  unsigned char c, d;
57
  ARMword x, y;
58
  int virgin = 1;
59
  struct fd_set readfds;
60
 
61
#ifdef DEBUG
62
  fprintf (stderr, "parent ()...\n");
63
#endif
64
 
65
panic_error:
66
 
67
  if (!virgin)
68
    {
69
#ifdef DEBUG
70
      fprintf (stderr, "Arghh! What is going on?\n");
71
#endif
72
      kill (child, SIGHUP);
73
      MYwrite_char (debugsock, RDP_Reset);
74
    }
75
 
76
  virgin = 0;
77
 
78
  while (1)
79
    {
80
 
81
      /* Wait either for the ARMulator or the debugger */
82
 
83
      FD_ZERO (&readfds);
84
      FD_SET (kidmum[0], &readfds);      /* Wait for messages from ARMulator */
85
      FD_SET (debugsock, &readfds);     /* Wait for messages from debugger */
86
 
87
#ifdef DEBUG
88
      fprintf (stderr, "Waiting for ARMulator or debugger... ");
89
#endif
90
 
91
      while ((i = select (nfds, &readfds, (fd_set *) 0, (fd_set *) 0, 0)) < 0)
92
        {
93
          perror ("select");
94
        }
95
 
96
#ifdef DEBUG
97
      fprintf (stderr, "(%d/2)", i);
98
#endif
99
 
100
      if (FD_ISSET (debugsock, &readfds))
101
        {
102
#ifdef DEBUG
103
          fprintf (stderr, "->debugger\n");
104
#endif
105
 
106
          /* Inside this rather large if statement with simply pass on a complete
107
             message to the ARMulator.  The reason we need to pass messages on one
108
             at a time is that we have to know whether the message is an OSOpReply
109
             or an info(stop), so that we can take different action in those
110
             cases. */
111
 
112
          if (MYread_char (debugsock, &message))
113
            goto panic_error;
114
 
115
          switch (message)
116
            {
117
            case RDP_Start:
118
              /* Open and/or Initialise */
119
#ifdef DEBUG
120
              fprintf (stderr, "RDP Open\n");
121
#endif
122
              if (MYread_char (debugsock, &c))  /* type */
123
                goto panic_error;
124
 
125
              if (MYread_word (debugsock, &x))  /* memory size */
126
                goto panic_error;
127
 
128
              MYwrite_char (mumkid[1], message);
129
              MYwrite_char (mumkid[1], c);
130
              MYwrite_word (mumkid[1], x);
131
              if (c & 0x2)
132
                {
133
                  passon (debugsock, mumkid[1], 1);     /* speed */
134
                }
135
              break;
136
 
137
            case RDP_End:
138
              /* Close and Finalise */
139
#ifdef DEBUG
140
              fprintf (stderr, "RDP Close\n");
141
#endif
142
              MYwrite_char (mumkid[1], message);
143
              break;
144
 
145
            case RDP_Read:
146
              /* Read Memory Address */
147
#ifdef DEBUG
148
              fprintf (stderr, "RDP Read Memory\n");
149
#endif
150
              MYwrite_char (mumkid[1], message);
151
              if (passon (debugsock, mumkid[1], 4))
152
                goto panic_error;       /* address */
153
              if (MYread_word (debugsock, &nbytes))
154
                goto panic_error;       /* nbytes */
155
              MYwrite_word (mumkid[1], nbytes);
156
              break;
157
 
158
            case RDP_Write:
159
              /* Write Memory Address */
160
#ifdef DEBUG
161
              fprintf (stderr, "RDP Write Memory\n");
162
#endif
163
              if (MYread_word (debugsock, &x))
164
                goto panic_error;       /* address */
165
 
166
              if (MYread_word (debugsock, &y))
167
                goto panic_error;       /* nbytes */
168
 
169
              MYwrite_char (mumkid[1], message);
170
              MYwrite_word (mumkid[1], x);
171
              MYwrite_word (mumkid[1], y);
172
              passon (debugsock, mumkid[1], y); /* actual data */
173
              break;
174
 
175
            case RDP_CPUread:
176
              /* Read CPU State */
177
#ifdef DEBUG
178
              fprintf (stderr, "RDP Read CPU\n");
179
#endif
180
              if (MYread_char (debugsock, &c))
181
                goto panic_error;       /* mode */
182
 
183
              if (MYread_word (debugsock, &mask))
184
                goto panic_error;       /* mask */
185
 
186
              MYwrite_char (mumkid[1], message);
187
              MYwrite_char (mumkid[1], c);
188
              MYwrite_word (mumkid[1], mask);
189
              break;
190
 
191
            case RDP_CPUwrite:
192
              /* Write CPU State */
193
#ifdef DEBUG
194
              fprintf (stderr, "RDP Write CPU\n");
195
#endif
196
              if (MYread_char (debugsock, &c))
197
                goto panic_error;       /* mode */
198
 
199
              if (MYread_word (debugsock, &x))
200
                goto panic_error;       /* mask */
201
 
202
              MYwrite_char (mumkid[1], message);
203
              MYwrite_char (mumkid[1], c);
204
              MYwrite_word (mumkid[1], x);
205
              for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
206
                if ((k & x) && passon (debugsock, mumkid[1], 4))
207
                  goto panic_error;
208
              break;
209
 
210
            case RDP_CPread:
211
              /* Read Co-Processor State */
212
#ifdef DEBUG
213
              fprintf (stderr, "RDP Read CP state\n");
214
#endif
215
              if (MYread_char (debugsock, &CPnum))
216
                goto panic_error;
217
 
218
              if (MYread_word (debugsock, &mask))
219
                goto panic_error;
220
 
221
              MYwrite_char (mumkid[1], message);
222
              MYwrite_char (mumkid[1], CPnum);
223
              MYwrite_word (mumkid[1], mask);
224
              break;
225
 
226
            case RDP_CPwrite:
227
              /* Write Co-Processor State */
228
#ifdef DEBUG
229
              fprintf (stderr, "RDP Write CP state\n");
230
#endif
231
              if (MYread_char (debugsock, &CPnum))
232
                goto panic_error;
233
 
234
              if (MYread_word (debugsock, &mask))
235
                goto panic_error;
236
 
237
              MYwrite_char (mumkid[1], message);
238
              MYwrite_char (mumkid[1], c);
239
              MYwrite_char (mumkid[1], x);
240
              for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
241
                if (k & x)
242
                  {
243
                    if ((c == 1 || c == 2) && k <= 128)
244
                      {
245
                        /* FP register = 12 bytes + 4 bytes format */
246
                        if (passon (debugsock, mumkid[1], 16))
247
                          goto panic_error;
248
                      }
249
                    else
250
                      {
251
                        /* Normal register = 4 bytes */
252
                        if (passon (debugsock, mumkid[1], 4))
253
                          goto panic_error;
254
                      }
255
                  }
256
              break;
257
 
258
            case RDP_SetBreak:
259
              /* Set Breakpoint */
260
#ifdef DEBUG
261
              fprintf (stderr, "RDP Set Breakpoint\n");
262
#endif
263
              if (MYread_word (debugsock, &x))
264
                goto panic_error;       /* address */
265
 
266
              if (MYread_char (debugsock, &c))
267
                goto panic_error;       /* type */
268
 
269
              MYwrite_char (mumkid[1], message);
270
              MYwrite_word (mumkid[1], x);
271
              MYwrite_char (mumkid[1], c);
272
              if (((c & 0xf) >= 5) && passon (debugsock, mumkid[1], 4))
273
                goto panic_error;       /* bound */
274
              break;
275
 
276
            case RDP_ClearBreak:
277
              /* Clear Breakpoint */
278
#ifdef DEBUG
279
              fprintf (stderr, "RDP Clear Breakpoint\n");
280
#endif
281
              MYwrite_char (mumkid[1], message);
282
              if (passon (debugsock, mumkid[1], 4))
283
                goto panic_error;       /* point */
284
              break;
285
 
286
            case RDP_SetWatch:
287
              /* Set Watchpoint */
288
#ifdef DEBUG
289
              fprintf (stderr, "RDP Set Watchpoint\n");
290
#endif
291
              if (MYread_word (debugsock, &x))
292
                goto panic_error;       /* address */
293
 
294
              if (MYread_char (debugsock, &c))
295
                goto panic_error;       /* type */
296
 
297
              if (MYread_char (debugsock, &d))
298
                goto panic_error;       /* datatype */
299
 
300
              MYwrite_char (mumkid[1], message);
301
              MYwrite_word (mumkid[1], x);
302
              MYwrite_char (mumkid[1], c);
303
              MYwrite_char (mumkid[1], d);
304
              if (((c & 0xf) >= 5) && passon (debugsock, mumkid[1], 4))
305
                goto panic_error;       /* bound */
306
              break;
307
 
308
            case RDP_ClearWatch:
309
              /* Clear Watchpoint */
310
#ifdef DEBUG
311
              fprintf (stderr, "RDP Clear Watchpoint\n");
312
#endif
313
              MYwrite_char (mumkid[1], message);
314
              if (passon (debugsock, mumkid[1], 4))
315
                goto panic_error;       /* point */
316
              break;
317
 
318
            case RDP_Execute:
319
              /* Excecute */
320
#ifdef DEBUG
321
              fprintf (stderr, "RDP Execute\n");
322
#endif
323
 
324
              /* LEAVE THIS ONE 'TIL LATER... */
325
              /* NEED TO WORK THINGS OUT */
326
 
327
              /* NO ASCYNCHROUS RUNNING */
328
 
329
              if (MYread_char (debugsock, &c))
330
                goto panic_error;       /* return */
331
 
332
              /* Remember incase bit 7 is set and we have to send back a word */
333
              exreturn = c;
334
 
335
              MYwrite_char (mumkid[1], message);
336
              MYwrite_char (mumkid[1], c);
337
              break;
338
 
339
            case RDP_Step:
340
              /* Step */
341
#ifdef DEBUG
342
              fprintf (stderr, "RDP Step\n");
343
#endif
344
 
345
              if (MYread_char (debugsock, &c))
346
                goto panic_error;       /* return */
347
 
348
              if (MYread_word (debugsock, &x))
349
                goto panic_error;       /* ninstr */
350
 
351
              MYwrite_char (mumkid[1], message);
352
              MYwrite_char (mumkid[1], c);
353
              MYwrite_word (mumkid[1], x);
354
              break;
355
 
356
            case RDP_Info:
357
              /* Info */
358
#ifdef DEBUG
359
              fprintf (stderr, "RDP Info\n");
360
#endif
361
              /* INFO TARGET, SET RDI LEVEL */
362
              if (MYread_word (debugsock, &messagetype))
363
                goto panic_error;       /* info */
364
 
365
              switch (messagetype)
366
                {
367
                case RDIInfo_Target:
368
                  MYwrite_char (mumkid[1], message);
369
                  MYwrite_word (mumkid[1], messagetype);
370
                  break;
371
 
372
                case RDISet_RDILevel:
373
                  MYwrite_char (mumkid[1], message);
374
                  MYwrite_word (mumkid[1], messagetype);
375
                  if (passon (debugsock, mumkid[1], 1))
376
                    goto panic_error;   /* argument */
377
                  break;
378
 
379
                case RDISet_Cmdline:
380
                  /* Got to pass on a string argument */
381
                  MYwrite_char (mumkid[1], message);
382
                  MYwrite_word (mumkid[1], messagetype);
383
                  do
384
                    {
385
                      if (MYread_char (debugsock, &c))
386
                        goto panic_error;
387
 
388
                      MYwrite_char (mumkid[1], c);
389
                    }
390
                  while (c);
391
                  break;
392
 
393
                case RDISignal_Stop:
394
                  kill (child, SIGUSR1);
395
                  MYwrite_char (debugsock, RDP_Return);
396
                  MYwrite_char (debugsock, RDIError_UserInterrupt);
397
                  break;
398
 
399
                case RDIVector_Catch:
400
                  MYread_word (debugsock, &x);
401
                  MYwrite_char (mumkid[1], message);
402
                  MYwrite_word (mumkid[1], messagetype);
403
                  MYwrite_word (mumkid[1], x);
404
                  break;
405
 
406
                case RDIInfo_Step:
407
                  MYwrite_char (mumkid[1], message);
408
                  MYwrite_word (mumkid[1], messagetype);
409
                  break;
410
 
411
                case RDIInfo_Points:
412
                  MYwrite_char (mumkid[1], message);
413
                  MYwrite_word (mumkid[1], messagetype);
414
                  break;
415
 
416
                default:
417
                  fprintf (stderr, "Unrecognized RDIInfo request %d\n",
418
                           messagetype);
419
                  goto panic_error;
420
                }
421
              break;
422
 
423
            case RDP_OSOpReply:
424
              /* OS Operation Reply */
425
#ifdef DEBUG
426
              fprintf (stderr, "RDP OS Reply\n");
427
#endif
428
              MYwrite_char (mumkid[1], message);
429
              if (MYread_char (debugsock, &message))
430
                goto panic_error;
431
              MYwrite_char (mumkid[1], message);
432
              switch (message)
433
                {
434
                case 0:  /* return value i.e. nothing else. */
435
                  break;
436
 
437
                case 1: /* returns a byte... */
438
                  if (MYread_char (debugsock, &c))
439
                    goto panic_error;
440
 
441
                  MYwrite_char (mumkid[1], c);
442
                  break;
443
 
444
                case 2: /* returns a word... */
445
                  if (MYread_word (debugsock, &x))
446
                    goto panic_error;
447
 
448
                  MYwrite_word (mumkid[1], x);
449
                  break;
450
                }
451
              break;
452
 
453
            case RDP_Reset:
454
              /* Reset */
455
#ifdef DEBUG
456
              fprintf (stderr, "RDP Reset\n");
457
#endif
458
              MYwrite_char (mumkid[1], message);
459
              break;
460
 
461
            default:
462
              /* Hmm.. bad RDP operation */
463
              fprintf (stderr, "RDP Bad RDP request (%d)\n", message);
464
              MYwrite_char (debugsock, RDP_Return);
465
              MYwrite_char (debugsock, RDIError_UnimplementedMessage);
466
              break;
467
            }
468
        }
469
 
470
      if (FD_ISSET (kidmum[0], &readfds))
471
        {
472
#ifdef DEBUG
473
          fprintf (stderr, "->ARMulator\n");
474
#endif
475
          /* Anything we get from the ARMulator has to go to the debugger... */
476
          /* It is that simple! */
477
 
478
          passon (kidmum[0], debugsock, 1);
479
        }
480
    }
481
}

powered by: WebSVN 2.1.0

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