import gdb-2000-02-04 snapshot
[external/binutils.git] / sim / arm / kid.c
1 /*  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 }