1 /* The common simulator framework for GDB, the GNU Debugger.
2
3 Copyright 2002-2024 Free Software Foundation, Inc.
4
5 Contributed by Andrew Cagney and Red Hat.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 /* This must come before any other includes. */
23 #include "defs.h"
24
25 #include <errno.h>
26 #if HAVE_FCNTL_H
27 #include <fcntl.h>
28 #endif
29 #include <stdarg.h>
30 #include <stdint.h>
31 #include <stdlib.h>
32 #include <unistd.h>
33
34 #undef open
35
36 #include "sim-main.h"
37 #include "sim-io.h"
38 #include "sim/callback.h"
39
40 /* Define the rate at which the simulator should poll the host
41 for a quit. */
42 #ifndef POLL_QUIT_INTERVAL
43 #define POLL_QUIT_INTERVAL 0x10
44 #endif
45
46 static int poll_quit_count = POLL_QUIT_INTERVAL;
47
48 /* See the file include/callbacks.h for a description */
49
50
51 int
sim_io_init(SIM_DESC sd)52 sim_io_init (SIM_DESC sd)
53 {
54 return STATE_CALLBACK (sd)->init (STATE_CALLBACK (sd));
55 }
56
57
58 int
sim_io_shutdown(SIM_DESC sd)59 sim_io_shutdown (SIM_DESC sd)
60 {
61 return STATE_CALLBACK (sd)->shutdown (STATE_CALLBACK (sd));
62 }
63
64
65 int
sim_io_unlink(SIM_DESC sd,const char * f1)66 sim_io_unlink (SIM_DESC sd,
67 const char *f1)
68 {
69 return STATE_CALLBACK (sd)->unlink (STATE_CALLBACK (sd), f1);
70 }
71
72
73 int64_t
sim_io_time(SIM_DESC sd)74 sim_io_time (SIM_DESC sd)
75 {
76 return STATE_CALLBACK (sd)->time (STATE_CALLBACK (sd));
77 }
78
79
80 int
sim_io_system(SIM_DESC sd,const char * s)81 sim_io_system (SIM_DESC sd, const char *s)
82 {
83 return STATE_CALLBACK (sd)->system (STATE_CALLBACK (sd), s);
84 }
85
86
87 int
sim_io_rename(SIM_DESC sd,const char * f1,const char * f2)88 sim_io_rename (SIM_DESC sd,
89 const char *f1,
90 const char *f2)
91 {
92 return STATE_CALLBACK (sd)->rename (STATE_CALLBACK (sd), f1, f2);
93 }
94
95
96 int
sim_io_write_stdout(SIM_DESC sd,const char * buf,int len)97 sim_io_write_stdout (SIM_DESC sd,
98 const char *buf,
99 int len)
100 {
101 switch (CURRENT_STDIO) {
102 case DO_USE_STDIO:
103 return STATE_CALLBACK (sd)->write_stdout (STATE_CALLBACK (sd), buf, len);
104 break;
105 case DONT_USE_STDIO:
106 return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), 1, buf, len);
107 break;
108 default:
109 sim_io_error (sd, "sim_io_write_stdout: unaccounted switch\n");
110 break;
111 }
112 return 0;
113 }
114
115
116 void
sim_io_flush_stdout(SIM_DESC sd)117 sim_io_flush_stdout (SIM_DESC sd)
118 {
119 switch (CURRENT_STDIO) {
120 case DO_USE_STDIO:
121 STATE_CALLBACK (sd)->flush_stdout (STATE_CALLBACK (sd));
122 break;
123 case DONT_USE_STDIO:
124 break;
125 default:
126 sim_io_error (sd, "sim_io_flush_stdout: unaccounted switch\n");
127 break;
128 }
129 }
130
131
132 int
sim_io_write_stderr(SIM_DESC sd,const char * buf,int len)133 sim_io_write_stderr (SIM_DESC sd,
134 const char *buf,
135 int len)
136 {
137 switch (CURRENT_STDIO) {
138 case DO_USE_STDIO:
139 return STATE_CALLBACK (sd)->write_stderr (STATE_CALLBACK (sd), buf, len);
140 break;
141 case DONT_USE_STDIO:
142 return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), 2, buf, len);
143 break;
144 default:
145 sim_io_error (sd, "sim_io_write_stderr: unaccounted switch\n");
146 break;
147 }
148 return 0;
149 }
150
151
152 void
sim_io_flush_stderr(SIM_DESC sd)153 sim_io_flush_stderr (SIM_DESC sd)
154 {
155 switch (CURRENT_STDIO) {
156 case DO_USE_STDIO:
157 STATE_CALLBACK (sd)->flush_stderr (STATE_CALLBACK (sd));
158 break;
159 case DONT_USE_STDIO:
160 break;
161 default:
162 sim_io_error (sd, "sim_io_flush_stderr: unaccounted switch\n");
163 break;
164 }
165 }
166
167
168 int
sim_io_write(SIM_DESC sd,int fd,const char * buf,int len)169 sim_io_write (SIM_DESC sd,
170 int fd,
171 const char *buf,
172 int len)
173 {
174 return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), fd, buf, len);
175 }
176
177
178 int
sim_io_read_stdin(SIM_DESC sd,char * buf,int len)179 sim_io_read_stdin (SIM_DESC sd,
180 char *buf,
181 int len)
182 {
183 switch (CURRENT_STDIO) {
184 case DO_USE_STDIO:
185 return STATE_CALLBACK (sd)->read_stdin (STATE_CALLBACK (sd), buf, len);
186 break;
187 case DONT_USE_STDIO:
188 return STATE_CALLBACK (sd)->read (STATE_CALLBACK (sd), 0, buf, len);
189 break;
190 default:
191 sim_io_error (sd, "sim_io_read_stdin: unaccounted switch\n");
192 break;
193 }
194 return 0;
195 }
196
197
198 int
sim_io_read(SIM_DESC sd,int fd,char * buf,int len)199 sim_io_read (SIM_DESC sd, int fd,
200 char *buf,
201 int len)
202 {
203 return STATE_CALLBACK (sd)->read (STATE_CALLBACK (sd), fd, buf, len);
204 }
205
206
207 int
sim_io_open(SIM_DESC sd,const char * name,int flags)208 sim_io_open (SIM_DESC sd,
209 const char *name,
210 int flags)
211 {
212 return STATE_CALLBACK (sd)->open (STATE_CALLBACK (sd), name, flags);
213 }
214
215
216 int64_t
sim_io_lseek(SIM_DESC sd,int fd,int64_t off,int way)217 sim_io_lseek (SIM_DESC sd,
218 int fd,
219 int64_t off,
220 int way)
221 {
222 return STATE_CALLBACK (sd)->lseek (STATE_CALLBACK (sd), fd, off, way);
223 }
224
225
226 int
sim_io_isatty(SIM_DESC sd,int fd)227 sim_io_isatty (SIM_DESC sd,
228 int fd)
229 {
230 return STATE_CALLBACK (sd)->isatty (STATE_CALLBACK (sd), fd);
231 }
232
233
234 int
sim_io_get_errno(SIM_DESC sd)235 sim_io_get_errno (SIM_DESC sd)
236 {
237 return STATE_CALLBACK (sd)->get_errno (STATE_CALLBACK (sd));
238 }
239
240
241 int
sim_io_close(SIM_DESC sd,int fd)242 sim_io_close (SIM_DESC sd,
243 int fd)
244 {
245 return STATE_CALLBACK (sd)->close (STATE_CALLBACK (sd), fd);
246 }
247
248
249 void
sim_io_printf(SIM_DESC sd,const char * fmt,...)250 sim_io_printf (SIM_DESC sd,
251 const char *fmt,
252 ...)
253 {
254 va_list ap;
255 va_start (ap, fmt);
256 STATE_CALLBACK (sd)->vprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
257 va_end (ap);
258 }
259
260
261 void
sim_io_vprintf(SIM_DESC sd,const char * fmt,va_list ap)262 sim_io_vprintf (SIM_DESC sd,
263 const char *fmt,
264 va_list ap)
265 {
266 STATE_CALLBACK (sd)->vprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
267 }
268
269
270 void
sim_io_eprintf(SIM_DESC sd,const char * fmt,...)271 sim_io_eprintf (SIM_DESC sd,
272 const char *fmt,
273 ...)
274 {
275 va_list ap;
276 va_start (ap, fmt);
277 STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
278 va_end (ap);
279 }
280
281
282 void
sim_io_evprintf(SIM_DESC sd,const char * fmt,va_list ap)283 sim_io_evprintf (SIM_DESC sd,
284 const char *fmt,
285 va_list ap)
286 {
287 STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
288 }
289
290
291 void
sim_io_error(SIM_DESC sd,const char * fmt,...)292 sim_io_error (SIM_DESC sd,
293 const char *fmt,
294 ...)
295 {
296 if (sd == NULL || STATE_CALLBACK (sd) == NULL) {
297 va_list ap;
298 va_start (ap, fmt);
299 vfprintf (stderr, fmt, ap);
300 va_end (ap);
301 fprintf (stderr, "\n");
302 abort ();
303 }
304 else {
305 va_list ap;
306 va_start (ap, fmt);
307 STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
308 va_end (ap);
309 /* The %s avoids empty printf compiler warnings. Not ideal, but we want
310 error's side-effect where it halts processing. */
311 STATE_CALLBACK (sd)->error (STATE_CALLBACK (sd), "%s", "");
312 }
313 }
314
315
316 void
sim_io_poll_quit(SIM_DESC sd)317 sim_io_poll_quit (SIM_DESC sd)
318 {
319 if (STATE_CALLBACK (sd)->poll_quit != NULL && poll_quit_count-- < 0)
320 {
321 poll_quit_count = POLL_QUIT_INTERVAL;
322 if (STATE_CALLBACK (sd)->poll_quit (STATE_CALLBACK (sd)))
323 sim_stop (sd);
324 }
325 }
326
327
328 /* Based on gdb-4.17/sim/ppc/main.c:sim_io_read_stdin().
329
330 FIXME: Should not be calling fcntl() or grubbing around inside of
331 ->fdmap and ->errno.
332
333 FIXME: Some completly new mechanism for handling the general
334 problem of asynchronous IO is needed.
335
336 FIXME: This function does not supress the echoing (ECHO) of input.
337 Consequently polled input is always displayed.
338
339 FIXME: This function does not perform uncooked reads.
340 Consequently, data will not be read until an EOLN character has
341 been entered. A cntrl-d may force the early termination of a line */
342
343
344 int
sim_io_poll_read(SIM_DESC sd,int sim_io_fd,char * buf,int sizeof_buf)345 sim_io_poll_read (SIM_DESC sd,
346 int sim_io_fd,
347 char *buf,
348 int sizeof_buf)
349 {
350 #if defined(O_NONBLOCK) && defined(F_GETFL) && defined(F_SETFL)
351 int fd = STATE_CALLBACK (sd)->fdmap[sim_io_fd];
352 int flags;
353 int status;
354 int nr_read;
355 int result;
356 STATE_CALLBACK (sd)->last_errno = 0;
357 /* get the old status */
358 flags = fcntl (fd, F_GETFL, 0);
359 if (flags == -1)
360 {
361 perror ("sim_io_poll_read");
362 return 0;
363 }
364 /* temp, disable blocking IO */
365 status = fcntl (fd, F_SETFL, flags | O_NONBLOCK);
366 if (status == -1)
367 {
368 perror ("sim_io_read_stdin");
369 return 0;
370 }
371 /* try for input */
372 nr_read = read (fd, buf, sizeof_buf);
373 if (nr_read >= 0)
374 {
375 /* printf ("<nr-read=%d>\n", nr_read); */
376 result = nr_read;
377 }
378 else
379 { /* nr_read < 0 */
380 result = -1;
381 STATE_CALLBACK (sd)->last_errno = errno;
382 }
383 /* return to regular vewing */
384 status = fcntl (fd, F_SETFL, flags);
385 if (status == -1)
386 {
387 perror ("sim_io_read_stdin");
388 /* return 0; */
389 }
390 return result;
391 #else
392 return sim_io_read (sd, sim_io_fd, buf, sizeof_buf);
393 #endif
394 }
395
396 int
sim_io_stat(SIM_DESC sd,const char * path,struct stat * buf)397 sim_io_stat (SIM_DESC sd, const char *path, struct stat *buf)
398 {
399 return STATE_CALLBACK (sd)->to_stat (STATE_CALLBACK (sd), path, buf);
400 }
401
402 int
sim_io_fstat(SIM_DESC sd,int fd,struct stat * buf)403 sim_io_fstat (SIM_DESC sd, int fd, struct stat *buf)
404 {
405 return STATE_CALLBACK (sd)->to_fstat (STATE_CALLBACK (sd), fd, buf);
406 }
407