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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [sim/] [arm/] [communicate.c] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/*  communicate.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
/* Functions to read and write characters or groups of characters         */
20
/* down sockets or pipes.  Those that return a value return -1 on failure */
21
/* and 0 on success.                                                      */
22
/**************************************************************************/
23
 
24
#include <sys/time.h>
25
#include <sys/types.h>
26
#include <sys/socket.h>
27
#include <netinet/in.h>
28
 
29
#include "armdefs.h"
30
 
31
/* The socket to the debugger */
32
int debugsock;
33
 
34
/* The maximum number of file descriptors */
35
extern int nfds;
36
 
37
/* The socket handle */
38
extern int sockethandle;
39
 
40
/* Read and Write routines down a pipe or socket */
41
 
42
/****************************************************************/
43
/* Read an individual character.                                */
44
/* All other read functions rely on this one.                   */
45
/* It waits 15 seconds until there is a character available: if */
46
/* no character is available, then it timeouts and returns -1.  */
47
/****************************************************************/
48
int
49
MYread_char (int sock, unsigned char *c)
50
{
51
  int i;
52
  fd_set readfds;
53
  struct timeval timeout = { 15, 0 };
54
  struct sockaddr_in isa;
55
 
56
retry:
57
 
58
  FD_ZERO (&readfds);
59
  FD_SET (sock, &readfds);
60
 
61
  i = select (nfds, &readfds, (fd_set *) 0, (fd_set *) 0, &timeout);
62
 
63
  if (i < 0)
64
    {
65
      perror ("select");
66
      exit (1);
67
    }
68
 
69
  if (!i)
70
    {
71
      fprintf (stderr, "read: Timeout\n");
72
      return -1;
73
    }
74
 
75
  if ((i = read (sock, c, 1)) < 1)
76
    {
77
      if (!i && sock == debugsock)
78
        {
79
          fprintf (stderr, "Connection with debugger severed.\n");
80
          /* This shouldn't be necessary for a detached armulator, but
81
             the armulator cannot be cold started a second time, so
82
             this is probably preferable to locking up.  */
83
          return -1;
84
          fprintf (stderr, "Waiting for connection from debugger...");
85
          debugsock = accept (sockethandle, &isa, &i);
86
          if (debugsock == -1)
87
            {                   /* Now we are in serious trouble... */
88
              perror ("accept");
89
              return -1;
90
            }
91
          fprintf (stderr, " done.\nConnection Established.\n");
92
          sock = debugsock;
93
          goto retry;
94
        }
95
      perror ("read");
96
      return -1;
97
    }
98
 
99
#ifdef DEBUG
100
  if (sock == debugsock)
101
    fprintf (stderr, "<%02x ", *c);
102
#endif
103
 
104
  return 0;
105
}
106
 
107
/****************************************************************/
108
/* Read an individual character.                                */
109
/* It waits until there is a character available. Returns -1 if */
110
/* an error occurs.                                             */
111
/****************************************************************/
112
int
113
MYread_charwait (int sock, unsigned char *c)
114
{
115
  int i;
116
  fd_set readfds;
117
  struct sockaddr_in isa;
118
 
119
retry:
120
 
121
  FD_ZERO (&readfds);
122
  FD_SET (sock, &readfds);
123
 
124
  i = select (nfds, &readfds,
125
              (fd_set *) 0, (fd_set *) 0, (struct timeval *) 0);
126
 
127
  if (i < 0)
128
    {
129
      perror ("select");
130
      exit (-1);
131
    }
132
 
133
  if ((i = read (sock, c, 1)) < 1)
134
    {
135
      if (!i && sock == debugsock)
136
        {
137
          fprintf (stderr, "Connection with debugger severed.\n");
138
          return -1;
139
          fprintf (stderr, "Waiting for connection from debugger...");
140
          debugsock = accept (sockethandle, &isa, &i);
141
          if (debugsock == -1)
142
            {                   /* Now we are in serious trouble... */
143
              perror ("accept");
144
              return -1;
145
            }
146
          fprintf (stderr, " done.\nConnection Established.\n");
147
          sock = debugsock;
148
          goto retry;
149
        }
150
      perror ("read");
151
      return -1;
152
    }
153
 
154
#ifdef DEBUG
155
  if (sock == debugsock)
156
    fprintf (stderr, "<%02x ", *c);
157
#endif
158
 
159
  return 0;
160
}
161
 
162
void
163
MYwrite_char (int sock, unsigned char c)
164
{
165
 
166
  if (write (sock, &c, 1) < 1)
167
    perror ("write");
168
#ifdef DEBUG
169
  if (sock == debugsock)
170
    fprintf (stderr, ">%02x ", c);
171
#endif
172
}
173
 
174
int
175
MYread_word (int sock, ARMword * here)
176
{
177
  unsigned char a, b, c, d;
178
 
179
  if (MYread_char (sock, &a) < 0)
180
    return -1;
181
  if (MYread_char (sock, &b) < 0)
182
    return -1;
183
  if (MYread_char (sock, &c) < 0)
184
    return -1;
185
  if (MYread_char (sock, &d) < 0)
186
    return -1;
187
  *here = a | b << 8 | c << 16 | d << 24;
188
  return 0;
189
}
190
 
191
void
192
MYwrite_word (int sock, ARMword i)
193
{
194
  MYwrite_char (sock, i & 0xff);
195
  MYwrite_char (sock, (i & 0xff00) >> 8);
196
  MYwrite_char (sock, (i & 0xff0000) >> 16);
197
  MYwrite_char (sock, (i & 0xff000000) >> 24);
198
}
199
 
200
void
201
MYwrite_string (int sock, char *s)
202
{
203
  int i;
204
  for (i = 0; MYwrite_char (sock, s[i]), s[i]; i++);
205
}
206
 
207
int
208
MYread_FPword (int sock, char *putinhere)
209
{
210
  int i;
211
  for (i = 0; i < 16; i++)
212
    if (MYread_char (sock, &putinhere[i]) < 0)
213
      return -1;
214
  return 0;
215
}
216
 
217
void
218
MYwrite_FPword (int sock, char *fromhere)
219
{
220
  int i;
221
  for (i = 0; i < 16; i++)
222
    MYwrite_char (sock, fromhere[i]);
223
}
224
 
225
/* Takes n bytes from source and those n bytes */
226
/* down to dest */
227
int
228
passon (int source, int dest, int n)
229
{
230
  char *p;
231
  int i;
232
 
233
  p = (char *) malloc (n);
234
  if (!p)
235
    {
236
      perror ("Out of memory\n");
237
      exit (1);
238
    }
239
  if (n)
240
    {
241
      for (i = 0; i < n; i++)
242
        if (MYread_char (source, &p[i]) < 0)
243
          return -1;
244
 
245
#ifdef DEBUG
246
      if (dest == debugsock)
247
        for (i = 0; i < n; i++)
248
          fprintf (stderr, ")%02x ", (unsigned char) p[i]);
249
#endif
250
 
251
      write (dest, p, n);
252
    }
253
  free (p);
254
  return 0;
255
}

powered by: WebSVN 2.1.0

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