1 /* Support for connecting Guile's stdio to GDB's.
2 as well as r/w memory via ports.
4 Copyright (C) 2014-2015 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* See README file in this directory for implementation notes, coding
22 conventions, et.al. */
25 #include "gdb_select.h"
28 #include "guile-internal.h"
31 #if defined (HAVE_POLL_H)
33 #elif defined (HAVE_SYS_POLL_H)
38 /* A ui-file for sending output to Guile. */
46 /* Data for a memory port. */
50 /* Bounds of memory range this port is allowed to access: [start, end).
51 This means that 0xff..ff is not accessible. I can live with that. */
54 /* (end - start), recorded for convenience. */
57 /* Think of this as the lseek value maintained by the kernel.
58 This value is always in the range [0, size]. */
61 /* The size of the internal r/w buffers.
62 Scheme ports aren't a straightforward mapping to memory r/w.
63 Generally the user specifies how much to r/w and all access is
64 unbuffered. We don't try to provide equivalent access, but we allow
65 the user to specify these values to help get something similar. */
66 unsigned read_buf_size
, write_buf_size
;
69 /* Copies of the original system input/output/error ports.
70 These are recorded for debugging purposes. */
71 static SCM orig_input_port_scm
;
72 static SCM orig_output_port_scm
;
73 static SCM orig_error_port_scm
;
75 /* This is the stdio port descriptor, scm_ptob_descriptor. */
76 static scm_t_bits stdio_port_desc
;
78 /* Note: scm_make_port_type takes a char * instead of a const char *. */
79 static /*const*/ char stdio_port_desc_name
[] = "gdb:stdio-port";
81 /* Names of each gdb port. */
82 static const char input_port_name
[] = "gdb:stdin";
83 static const char output_port_name
[] = "gdb:stdout";
84 static const char error_port_name
[] = "gdb:stderr";
86 /* This is the actual port used from Guile.
87 We don't expose these to the user though, to ensure they're not
89 static SCM input_port_scm
;
90 static SCM output_port_scm
;
91 static SCM error_port_scm
;
93 /* Magic number to identify port ui-files.
94 Actually, the address of this variable is the magic number. */
95 static int file_port_magic
;
97 /* Internal enum for specifying output port. */
98 enum oport
{ GDB_STDOUT
, GDB_STDERR
};
100 /* This is the memory port descriptor, scm_ptob_descriptor. */
101 static scm_t_bits memory_port_desc
;
103 /* Note: scm_make_port_type takes a char * instead of a const char *. */
104 static /*const*/ char memory_port_desc_name
[] = "gdb:memory-port";
106 /* The default amount of memory to fetch for each read/write request.
107 Scheme ports don't provide a way to specify the size of a read,
108 which is important to us to minimize the number of inferior interactions,
109 which over a remote link can be important. To compensate we augment the
110 port API with a new function that let's the user specify how much the next
111 read request should fetch. This is the initial value for each new port. */
112 static const unsigned default_read_buf_size
= 16;
113 static const unsigned default_write_buf_size
= 16;
115 /* Arbitrarily limit memory port buffers to 1 byte to 4K. */
116 static const unsigned min_memory_port_buf_size
= 1;
117 static const unsigned max_memory_port_buf_size
= 4096;
119 /* "out of range" error message for buf sizes. */
120 static char *out_of_range_buf_size
;
122 /* Keywords used by open-memory. */
123 static SCM mode_keyword
;
124 static SCM start_keyword
;
125 static SCM size_keyword
;
127 /* Helper to do the low level work of opening a port.
128 Newer versions of Guile (2.1.x) have scm_c_make_port. */
131 ioscm_open_port (scm_t_bits port_type
, long mode_bits
)
135 #if 0 /* TODO: Guile doesn't export this. What to do? */
136 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
139 port
= scm_new_port_table_entry (port_type
);
141 SCM_SET_CELL_TYPE (port
, port_type
| mode_bits
);
143 #if 0 /* TODO: Guile doesn't export this. What to do? */
144 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
150 /* Support for connecting Guile's stdio ports to GDB's stdio ports. */
152 /* The scm_t_ptob_descriptor.input_waiting "method".
153 Return a lower bound on the number of bytes available for input. */
156 ioscm_input_waiting (SCM port
)
160 if (! scm_is_eq (port
, input_port_scm
))
165 /* This is copied from libguile/fports.c. */
166 struct pollfd pollfd
= { fdes
, POLLIN
, 0 };
167 static int use_poll
= -1;
171 /* This is copied from event-loop.c: poll cannot be used for stdin on
172 m68k-motorola-sysv. */
173 struct pollfd test_pollfd
= { fdes
, POLLIN
, 0 };
175 if (poll (&test_pollfd
, 1, 0) == 1 && (test_pollfd
.revents
& POLLNVAL
))
183 /* Guile doesn't export SIGINT hooks like Python does.
184 For now pass EINTR to scm_syserror, that's what fports.c does. */
185 if (poll (&pollfd
, 1, 0) < 0)
186 scm_syserror (FUNC_NAME
);
188 return pollfd
.revents
& POLLIN
? 1 : 0;
195 struct timeval timeout
;
197 int num_fds
= fdes
+ 1;
200 memset (&timeout
, 0, sizeof (timeout
));
201 FD_ZERO (&input_fds
);
202 FD_SET (fdes
, &input_fds
);
204 num_found
= gdb_select (num_fds
, &input_fds
, NULL
, NULL
, &timeout
);
207 /* Guile doesn't export SIGINT hooks like Python does.
208 For now pass EINTR to scm_syserror, that's what fports.c does. */
209 scm_syserror (FUNC_NAME
);
211 return num_found
> 0 && FD_ISSET (fdes
, &input_fds
);
215 /* The scm_t_ptob_descriptor.fill_input "method". */
218 ioscm_fill_input (SCM port
)
220 /* Borrowed from libguile/fports.c. */
222 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
224 /* If we're called on stdout,stderr, punt. */
225 if (! scm_is_eq (port
, input_port_scm
))
226 return (scm_t_wchar
) EOF
; /* Set errno and return -1? */
228 gdb_flush (gdb_stdout
);
229 gdb_flush (gdb_stderr
);
231 count
= ui_file_read (gdb_stdin
, (char *) pt
->read_buf
, pt
->read_buf_size
);
233 scm_syserror (FUNC_NAME
);
235 return (scm_t_wchar
) EOF
;
237 pt
->read_pos
= pt
->read_buf
;
238 pt
->read_end
= pt
->read_buf
+ count
;
239 return *pt
->read_buf
;
242 /* Like fputstrn_filtered, but don't escape characters, except nul.
243 Also like fputs_filtered, but a length is specified. */
246 fputsn_filtered (const char *s
, size_t size
, struct ui_file
*stream
)
250 for (i
= 0; i
< size
; ++i
)
253 fputs_filtered ("\\000", stream
);
255 fputc_filtered (s
[i
], stream
);
259 /* Write to gdb's stdout or stderr. */
262 ioscm_write (SCM port
, const void *data
, size_t size
)
265 /* If we're called on stdin, punt. */
266 if (scm_is_eq (port
, input_port_scm
))
271 if (scm_is_eq (port
, error_port_scm
))
272 fputsn_filtered (data
, size
, gdb_stderr
);
274 fputsn_filtered (data
, size
, gdb_stdout
);
276 CATCH (except
, RETURN_MASK_ALL
)
278 GDBSCM_HANDLE_GDB_EXCEPTION (except
);
283 /* Flush gdb's stdout or stderr. */
286 ioscm_flush (SCM port
)
288 /* If we're called on stdin, punt. */
289 if (scm_is_eq (port
, input_port_scm
))
292 if (scm_is_eq (port
, error_port_scm
))
293 gdb_flush (gdb_stderr
);
295 gdb_flush (gdb_stdout
);
298 /* Initialize the gdb stdio port type.
300 N.B. isatty? will fail on these ports, it is only supported for file
301 ports. IWBN if we could "subclass" file ports. */
304 ioscm_init_gdb_stdio_port (void)
306 stdio_port_desc
= scm_make_port_type (stdio_port_desc_name
,
307 ioscm_fill_input
, ioscm_write
);
309 scm_set_port_input_waiting (stdio_port_desc
, ioscm_input_waiting
);
310 scm_set_port_flush (stdio_port_desc
, ioscm_flush
);
313 /* Subroutine of ioscm_make_gdb_stdio_port to simplify it.
314 Set up the buffers of port PORT.
315 MODE_BITS are the mode bits of PORT. */
318 ioscm_init_stdio_buffers (SCM port
, long mode_bits
)
320 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
321 #define GDB_STDIO_BUFFER_DEFAULT_SIZE 1024
322 int size
= mode_bits
& SCM_BUF0
? 0 : GDB_STDIO_BUFFER_DEFAULT_SIZE
;
323 int writing
= (mode_bits
& SCM_WRTNG
) != 0;
325 /* This is heavily copied from scm_fport_buffer_add. */
327 if (!writing
&& size
> 0)
330 = (unsigned char *) scm_gc_malloc_pointerless (size
, "port buffer");
331 pt
->read_pos
= pt
->read_end
= pt
->read_buf
;
332 pt
->read_buf_size
= size
;
336 pt
->read_pos
= pt
->read_buf
= pt
->read_end
= &pt
->shortbuf
;
337 pt
->read_buf_size
= 1;
340 if (writing
&& size
> 0)
343 = (unsigned char *) scm_gc_malloc_pointerless (size
, "port buffer");
344 pt
->write_pos
= pt
->write_buf
;
345 pt
->write_buf_size
= size
;
349 pt
->write_buf
= pt
->write_pos
= &pt
->shortbuf
;
350 pt
->write_buf_size
= 1;
352 pt
->write_end
= pt
->write_buf
+ pt
->write_buf_size
;
355 /* Create a gdb stdio port. */
358 ioscm_make_gdb_stdio_port (int fd
)
360 int is_a_tty
= isatty (fd
);
368 name
= input_port_name
;
369 mode_bits
= scm_mode_bits (is_a_tty
? "r0" : "r");
372 name
= output_port_name
;
373 mode_bits
= scm_mode_bits (is_a_tty
? "w0" : "w");
376 name
= error_port_name
;
377 mode_bits
= scm_mode_bits (is_a_tty
? "w0" : "w");
380 gdb_assert_not_reached ("bad stdio file descriptor");
383 port
= ioscm_open_port (stdio_port_desc
, mode_bits
);
385 scm_set_port_filename_x (port
, gdbscm_scm_from_c_string (name
));
387 ioscm_init_stdio_buffers (port
, mode_bits
);
392 /* (stdio-port? object) -> boolean */
395 gdbscm_stdio_port_p (SCM scm
)
397 /* This is copied from SCM_FPORTP. */
398 return scm_from_bool (!SCM_IMP (scm
)
399 && (SCM_TYP16 (scm
) == stdio_port_desc
));
402 /* GDB's ports are accessed via functions to keep them read-only. */
404 /* (input-port) -> port */
407 gdbscm_input_port (void)
409 return input_port_scm
;
412 /* (output-port) -> port */
415 gdbscm_output_port (void)
417 return output_port_scm
;
420 /* (error-port) -> port */
423 gdbscm_error_port (void)
425 return error_port_scm
;
428 /* Support for sending GDB I/O to Guile ports. */
431 ioscm_file_port_delete (struct ui_file
*file
)
433 ioscm_file_port
*stream
= ui_file_data (file
);
435 if (stream
->magic
!= &file_port_magic
)
436 internal_error (__FILE__
, __LINE__
,
437 _("ioscm_file_port_delete: bad magic number"));
442 ioscm_file_port_rewind (struct ui_file
*file
)
444 ioscm_file_port
*stream
= ui_file_data (file
);
446 if (stream
->magic
!= &file_port_magic
)
447 internal_error (__FILE__
, __LINE__
,
448 _("ioscm_file_port_rewind: bad magic number"));
450 scm_truncate_file (stream
->port
, 0);
454 ioscm_file_port_put (struct ui_file
*file
,
455 ui_file_put_method_ftype
*write
,
458 ioscm_file_port
*stream
= ui_file_data (file
);
460 if (stream
->magic
!= &file_port_magic
)
461 internal_error (__FILE__
, __LINE__
,
462 _("ioscm_file_port_put: bad magic number"));
464 /* This function doesn't meld with ports very well. */
468 ioscm_file_port_write (struct ui_file
*file
,
472 ioscm_file_port
*stream
= ui_file_data (file
);
474 if (stream
->magic
!= &file_port_magic
)
475 internal_error (__FILE__
, __LINE__
,
476 _("ioscm_pot_file_write: bad magic number"));
478 scm_c_write (stream
->port
, buffer
, length_buffer
);
481 /* Return a ui_file that writes to PORT. */
483 static struct ui_file
*
484 ioscm_file_port_new (SCM port
)
486 ioscm_file_port
*stream
= XCNEW (ioscm_file_port
);
487 struct ui_file
*file
= ui_file_new ();
489 set_ui_file_data (file
, stream
, ioscm_file_port_delete
);
490 set_ui_file_rewind (file
, ioscm_file_port_rewind
);
491 set_ui_file_put (file
, ioscm_file_port_put
);
492 set_ui_file_write (file
, ioscm_file_port_write
);
493 stream
->magic
= &file_port_magic
;
499 /* Helper routine for with-{output,error}-to-port. */
502 ioscm_with_output_to_port_worker (SCM port
, SCM thunk
, enum oport oport
,
503 const char *func_name
)
505 struct ui_file
*port_file
;
506 struct cleanup
*cleanups
;
509 SCM_ASSERT_TYPE (gdbscm_is_true (scm_output_port_p (port
)), port
,
510 SCM_ARG1
, func_name
, _("output port"));
511 SCM_ASSERT_TYPE (gdbscm_is_true (scm_thunk_p (thunk
)), thunk
,
512 SCM_ARG2
, func_name
, _("thunk"));
514 cleanups
= set_batch_flag_and_make_cleanup_restore_page_info ();
516 make_cleanup_restore_integer (&interpreter_async
);
517 interpreter_async
= 0;
519 port_file
= ioscm_file_port_new (port
);
521 make_cleanup_ui_file_delete (port_file
);
523 if (oport
== GDB_STDERR
)
525 make_cleanup_restore_ui_file (&gdb_stderr
);
526 gdb_stderr
= port_file
;
530 make_cleanup_restore_ui_file (&gdb_stdout
);
532 if (ui_out_redirect (current_uiout
, port_file
) < 0)
533 warning (_("Current output protocol does not support redirection"));
535 make_cleanup_ui_out_redirect_pop (current_uiout
);
537 gdb_stdout
= port_file
;
540 result
= gdbscm_safe_call_0 (thunk
, NULL
);
542 do_cleanups (cleanups
);
544 if (gdbscm_is_exception (result
))
545 gdbscm_throw (result
);
550 /* (%with-gdb-output-to-port port thunk) -> object
551 This function is experimental.
552 IWBN to not include "gdb" in the name, but it would collide with a standard
553 procedure, and it's common to import the gdb module without a prefix.
554 There are ways around this, but they're more cumbersome.
556 This has % in the name because it's experimental, and we want the
557 user-visible version to come from module (gdb experimental). */
560 gdbscm_percent_with_gdb_output_to_port (SCM port
, SCM thunk
)
562 return ioscm_with_output_to_port_worker (port
, thunk
, GDB_STDOUT
, FUNC_NAME
);
565 /* (%with-gdb-error-to-port port thunk) -> object
566 This function is experimental.
567 IWBN to not include "gdb" in the name, but it would collide with a standard
568 procedure, and it's common to import the gdb module without a prefix.
569 There are ways around this, but they're more cumbersome.
571 This has % in the name because it's experimental, and we want the
572 user-visible version to come from module (gdb experimental). */
575 gdbscm_percent_with_gdb_error_to_port (SCM port
, SCM thunk
)
577 return ioscm_with_output_to_port_worker (port
, thunk
, GDB_STDERR
, FUNC_NAME
);
580 /* Support for r/w memory via ports. */
582 /* Perform an "lseek" to OFFSET,WHENCE on memory port IOMEM.
583 OFFSET must be in the range [0,size].
584 The result is non-zero for success, zero for failure. */
587 ioscm_lseek_address (ioscm_memory_port
*iomem
, LONGEST offset
, int whence
)
589 CORE_ADDR new_current
;
591 gdb_assert (iomem
->current
<= iomem
->size
);
596 /* Catch over/underflow. */
597 if ((offset
< 0 && iomem
->current
+ offset
> iomem
->current
)
598 || (offset
> 0 && iomem
->current
+ offset
< iomem
->current
))
600 new_current
= iomem
->current
+ offset
;
603 new_current
= offset
;
608 new_current
= iomem
->size
;
611 /* TODO: Not supported yet. */
617 if (new_current
> iomem
->size
)
619 iomem
->current
= new_current
;
623 /* "fill_input" method for memory ports. */
626 gdbscm_memory_port_fill_input (SCM port
)
628 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
629 ioscm_memory_port
*iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
632 /* "current" is the offset of the first byte we want to read. */
633 gdb_assert (iomem
->current
<= iomem
->size
);
634 if (iomem
->current
== iomem
->size
)
637 /* Don't read outside the allowed memory range. */
638 to_read
= pt
->read_buf_size
;
639 if (to_read
> iomem
->size
- iomem
->current
)
640 to_read
= iomem
->size
- iomem
->current
;
642 if (target_read_memory (iomem
->start
+ iomem
->current
, pt
->read_buf
,
644 gdbscm_memory_error (FUNC_NAME
, _("error reading memory"), SCM_EOL
);
646 iomem
->current
+= to_read
;
647 pt
->read_pos
= pt
->read_buf
;
648 pt
->read_end
= pt
->read_buf
+ to_read
;
649 return *pt
->read_buf
;
652 /* "end_input" method for memory ports.
653 Clear the read buffer and adjust the file position for unread bytes. */
656 gdbscm_memory_port_end_input (SCM port
, int offset
)
658 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
659 ioscm_memory_port
*iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
660 size_t remaining
= pt
->read_end
- pt
->read_pos
;
662 /* Note: Use of "int offset" is specified by Guile ports API. */
663 if ((offset
< 0 && remaining
+ offset
> remaining
)
664 || (offset
> 0 && remaining
+ offset
< remaining
))
666 gdbscm_out_of_range_error (FUNC_NAME
, 0, scm_from_int (offset
),
667 _("overflow in offset calculation"));
673 pt
->read_pos
= pt
->read_end
;
674 /* Throw error if unread-char used at beginning of file
675 then attempting to write. Seems correct. */
676 if (!ioscm_lseek_address (iomem
, -offset
, SEEK_CUR
))
678 gdbscm_out_of_range_error (FUNC_NAME
, 0, scm_from_int (offset
),
683 pt
->rw_active
= SCM_PORT_NEITHER
;
686 /* "flush" method for memory ports. */
689 gdbscm_memory_port_flush (SCM port
)
691 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
692 ioscm_memory_port
*iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
693 size_t to_write
= pt
->write_pos
- pt
->write_buf
;
698 /* There's no way to indicate a short write, so if the request goes past
699 the end of the port's memory range, flag an error. */
700 if (to_write
> iomem
->size
- iomem
->current
)
702 gdbscm_out_of_range_error (FUNC_NAME
, 0,
703 gdbscm_scm_from_ulongest (to_write
),
704 _("writing beyond end of memory range"));
707 if (target_write_memory (iomem
->start
+ iomem
->current
, pt
->write_buf
,
709 gdbscm_memory_error (FUNC_NAME
, _("error writing memory"), SCM_EOL
);
711 iomem
->current
+= to_write
;
712 pt
->write_pos
= pt
->write_buf
;
713 pt
->rw_active
= SCM_PORT_NEITHER
;
716 /* "write" method for memory ports. */
719 gdbscm_memory_port_write (SCM port
, const void *data
, size_t size
)
721 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
722 ioscm_memory_port
*iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
724 /* There's no way to indicate a short write, so if the request goes past
725 the end of the port's memory range, flag an error. */
726 if (size
> iomem
->size
- iomem
->current
)
728 gdbscm_out_of_range_error (FUNC_NAME
, 0, gdbscm_scm_from_ulongest (size
),
729 _("writing beyond end of memory range"));
732 if (pt
->write_buf
== &pt
->shortbuf
)
734 /* Unbuffered port. */
735 if (target_write_memory (iomem
->start
+ iomem
->current
, data
, size
) != 0)
736 gdbscm_memory_error (FUNC_NAME
, _("error writing memory"), SCM_EOL
);
737 iomem
->current
+= size
;
741 /* Note: The edge case of what to do when the buffer exactly fills is
742 debatable. Guile flushes when the buffer exactly fills up, so we
743 do too. It's counter-intuitive to my mind, but in case there's a
744 subtlety somewhere that depends on this, we do the same. */
747 size_t space
= pt
->write_end
- pt
->write_pos
;
751 /* Data fits in buffer, and does not fill it. */
752 memcpy (pt
->write_pos
, data
, size
);
753 pt
->write_pos
+= size
;
757 memcpy (pt
->write_pos
, data
, space
);
758 pt
->write_pos
= pt
->write_end
;
759 gdbscm_memory_port_flush (port
);
761 const void *ptr
= ((const char *) data
) + space
;
762 size_t remaining
= size
- space
;
764 if (remaining
>= pt
->write_buf_size
)
766 if (target_write_memory (iomem
->start
+ iomem
->current
, ptr
,
768 gdbscm_memory_error (FUNC_NAME
, _("error writing memory"),
770 iomem
->current
+= remaining
;
774 memcpy (pt
->write_pos
, ptr
, remaining
);
775 pt
->write_pos
+= remaining
;
782 /* "seek" method for memory ports. */
785 gdbscm_memory_port_seek (SCM port
, scm_t_off offset
, int whence
)
787 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
788 ioscm_memory_port
*iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
792 if (pt
->rw_active
== SCM_PORT_WRITE
)
794 if (offset
!= 0 || whence
!= SEEK_CUR
)
796 gdbscm_memory_port_flush (port
);
797 rc
= ioscm_lseek_address (iomem
, offset
, whence
);
798 result
= iomem
->current
;
802 /* Read current position without disturbing the buffer,
803 but flag an error if what's in the buffer goes outside the
805 CORE_ADDR current
= iomem
->current
;
806 size_t delta
= pt
->write_pos
- pt
->write_buf
;
808 if (current
+ delta
< current
809 || current
+ delta
> iomem
->size
)
813 result
= current
+ delta
;
818 else if (pt
->rw_active
== SCM_PORT_READ
)
820 if (offset
!= 0 || whence
!= SEEK_CUR
)
822 scm_end_input (port
);
823 rc
= ioscm_lseek_address (iomem
, offset
, whence
);
824 result
= iomem
->current
;
828 /* Read current position without disturbing the buffer
829 (particularly the unread-char buffer). */
830 CORE_ADDR current
= iomem
->current
;
831 size_t remaining
= pt
->read_end
- pt
->read_pos
;
833 if (current
- remaining
> current
834 || current
- remaining
< iomem
->start
)
838 result
= current
- remaining
;
842 if (rc
!= 0 && pt
->read_buf
== pt
->putback_buf
)
844 size_t saved_remaining
= pt
->saved_read_end
- pt
->saved_read_pos
;
846 if (result
- saved_remaining
> result
847 || result
- saved_remaining
< iomem
->start
)
850 result
-= saved_remaining
;
854 else /* SCM_PORT_NEITHER */
856 rc
= ioscm_lseek_address (iomem
, offset
, whence
);
857 result
= iomem
->current
;
862 gdbscm_out_of_range_error (FUNC_NAME
, 0,
863 gdbscm_scm_from_longest (offset
),
867 /* TODO: The Guile API doesn't support 32x64. We can't fix that here,
868 and there's no need to throw an error if the new address can't be
869 represented in a scm_t_off. But we could return something less
874 /* "close" method for memory ports. */
877 gdbscm_memory_port_close (SCM port
)
879 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
880 ioscm_memory_port
*iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
882 gdbscm_memory_port_flush (port
);
884 if (pt
->read_buf
== pt
->putback_buf
)
885 pt
->read_buf
= pt
->saved_read_buf
;
886 if (pt
->read_buf
!= &pt
->shortbuf
)
887 xfree (pt
->read_buf
);
888 if (pt
->write_buf
!= &pt
->shortbuf
)
889 xfree (pt
->write_buf
);
890 scm_gc_free (iomem
, sizeof (*iomem
), "memory port");
895 /* "free" method for memory ports. */
898 gdbscm_memory_port_free (SCM port
)
900 gdbscm_memory_port_close (port
);
905 /* "print" method for memory ports. */
908 gdbscm_memory_port_print (SCM exp
, SCM port
, scm_print_state
*pstate
)
910 ioscm_memory_port
*iomem
= (ioscm_memory_port
*) SCM_STREAM (exp
);
911 char *type
= SCM_PTOBNAME (SCM_PTOBNUM (exp
));
913 scm_puts ("#<", port
);
914 scm_print_port_mode (exp
, port
);
915 /* scm_print_port_mode includes a trailing space. */
916 gdbscm_printf (port
, "%s %s-%s", type
,
917 hex_string (iomem
->start
), hex_string (iomem
->end
));
918 scm_putc ('>', port
);
922 /* Create the port type used for memory. */
925 ioscm_init_memory_port_type (void)
927 memory_port_desc
= scm_make_port_type (memory_port_desc_name
,
928 gdbscm_memory_port_fill_input
,
929 gdbscm_memory_port_write
);
931 scm_set_port_end_input (memory_port_desc
, gdbscm_memory_port_end_input
);
932 scm_set_port_flush (memory_port_desc
, gdbscm_memory_port_flush
);
933 scm_set_port_seek (memory_port_desc
, gdbscm_memory_port_seek
);
934 scm_set_port_close (memory_port_desc
, gdbscm_memory_port_close
);
935 scm_set_port_free (memory_port_desc
, gdbscm_memory_port_free
);
936 scm_set_port_print (memory_port_desc
, gdbscm_memory_port_print
);
939 /* Helper for gdbscm_open_memory to parse the mode bits.
940 An exception is thrown if MODE is invalid. */
943 ioscm_parse_mode_bits (const char *func_name
, const char *mode
)
948 if (*mode
!= 'r' && *mode
!= 'w')
950 gdbscm_out_of_range_error (func_name
, 0,
951 gdbscm_scm_from_c_string (mode
),
952 _("bad mode string"));
954 for (p
= mode
+ 1; *p
!= '\0'; ++p
)
963 gdbscm_out_of_range_error (func_name
, 0,
964 gdbscm_scm_from_c_string (mode
),
965 _("bad mode string"));
969 /* Kinda awkward to convert the mode from SCM -> string only to have Guile
970 convert it back to SCM, but that's the API we have to work with. */
971 mode_bits
= scm_mode_bits ((char *) mode
);
976 /* Helper for gdbscm_open_memory to finish initializing the port.
977 The port has address range [start,end).
978 This means that address of 0xff..ff is not accessible.
979 I can live with that. */
982 ioscm_init_memory_port (SCM port
, CORE_ADDR start
, CORE_ADDR end
)
985 ioscm_memory_port
*iomem
;
986 int buffered
= (SCM_CELL_WORD_0 (port
) & SCM_BUF0
) == 0;
988 gdb_assert (start
<= end
);
990 iomem
= (ioscm_memory_port
*) scm_gc_malloc_pointerless (sizeof (*iomem
),
993 iomem
->start
= start
;
995 iomem
->size
= end
- start
;
999 iomem
->read_buf_size
= default_read_buf_size
;
1000 iomem
->write_buf_size
= default_write_buf_size
;
1004 iomem
->read_buf_size
= 1;
1005 iomem
->write_buf_size
= 1;
1008 pt
= SCM_PTAB_ENTRY (port
);
1009 /* Match the expectation of `binary-port?'. */
1010 pt
->encoding
= NULL
;
1012 pt
->read_buf_size
= iomem
->read_buf_size
;
1013 pt
->write_buf_size
= iomem
->write_buf_size
;
1016 pt
->read_buf
= (unsigned char *) xmalloc (pt
->read_buf_size
);
1017 pt
->write_buf
= (unsigned char *) xmalloc (pt
->write_buf_size
);
1021 pt
->read_buf
= &pt
->shortbuf
;
1022 pt
->write_buf
= &pt
->shortbuf
;
1024 pt
->read_pos
= pt
->read_end
= pt
->read_buf
;
1025 pt
->write_pos
= pt
->write_buf
;
1026 pt
->write_end
= pt
->write_buf
+ pt
->write_buf_size
;
1028 SCM_SETSTREAM (port
, iomem
);
1031 /* Re-initialize a memory port, updating its read/write buffer sizes.
1032 An exception is thrown if the port is unbuffered.
1033 TODO: Allow switching buffered/unbuffered.
1034 An exception is also thrown if data is still buffered, except in the case
1035 where the buffer size isn't changing (since that's just a nop). */
1038 ioscm_reinit_memory_port (SCM port
, size_t read_buf_size
,
1039 size_t write_buf_size
, const char *func_name
)
1041 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1042 ioscm_memory_port
*iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
1044 gdb_assert (read_buf_size
>= min_memory_port_buf_size
1045 && read_buf_size
<= max_memory_port_buf_size
);
1046 gdb_assert (write_buf_size
>= min_memory_port_buf_size
1047 && write_buf_size
<= max_memory_port_buf_size
);
1049 /* First check if the port is unbuffered. */
1051 if (pt
->read_buf
== &pt
->shortbuf
)
1053 gdb_assert (pt
->write_buf
== &pt
->shortbuf
);
1054 scm_misc_error (func_name
, _("port is unbuffered: ~a"),
1058 /* Next check if anything is buffered. */
1060 if (read_buf_size
!= pt
->read_buf_size
1061 && pt
->read_end
!= pt
->read_buf
)
1063 scm_misc_error (func_name
, _("read buffer not empty: ~a"),
1067 if (write_buf_size
!= pt
->write_buf_size
1068 && pt
->write_pos
!= pt
->write_buf
)
1070 scm_misc_error (func_name
, _("write buffer not empty: ~a"),
1074 /* Now we can update the buffer sizes, but only if the size has changed. */
1076 if (read_buf_size
!= pt
->read_buf_size
)
1078 iomem
->read_buf_size
= read_buf_size
;
1079 pt
->read_buf_size
= read_buf_size
;
1080 xfree (pt
->read_buf
);
1081 pt
->read_buf
= (unsigned char *) xmalloc (pt
->read_buf_size
);
1082 pt
->read_pos
= pt
->read_end
= pt
->read_buf
;
1085 if (write_buf_size
!= pt
->write_buf_size
)
1087 iomem
->write_buf_size
= write_buf_size
;
1088 pt
->write_buf_size
= write_buf_size
;
1089 xfree (pt
->write_buf
);
1090 pt
->write_buf
= (unsigned char *) xmalloc (pt
->write_buf_size
);
1091 pt
->write_pos
= pt
->write_buf
;
1092 pt
->write_end
= pt
->write_buf
+ pt
->write_buf_size
;
1096 /* (open-memory [#:mode string] [#:start address] [#:size integer]) -> port
1097 Return a port that can be used for reading and writing memory.
1098 MODE is a string, and must be one of "r", "w", or "r+".
1099 "0" may be appended to MODE to mark the port as unbuffered.
1100 For compatibility "b" (binary) may also be appended, but we ignore it:
1101 memory ports are binary only.
1103 The chunk of memory that can be accessed can be bounded.
1104 If both START,SIZE are unspecified, all of memory can be accessed
1105 (except 0xff..ff). If only START is specified, all of memory from that
1106 point on can be accessed (except 0xff..ff). If only SIZE if specified,
1107 all memory in [0,SIZE) can be accessed. If both are specified, all memory
1108 in [START,START+SIZE) can be accessed.
1110 Note: If it becomes useful enough we can later add #:end as an alternative
1111 to #:size. For now it is left out.
1113 The result is a Scheme port, and its semantics are a bit odd for accessing
1114 memory (e.g., unget), but we don't try to hide this. It's a port.
1116 N.B. Seeks on the port must be in the range [0,size].
1117 This is for similarity with bytevector ports, and so that one can seek
1118 to the first byte. */
1121 gdbscm_open_memory (SCM rest
)
1123 const SCM keywords
[] = {
1124 mode_keyword
, start_keyword
, size_keyword
, SCM_BOOL_F
1127 CORE_ADDR start
= 0;
1129 int mode_arg_pos
= -1, start_arg_pos
= -1, size_arg_pos
= -1;
1134 gdbscm_parse_function_args (FUNC_NAME
, SCM_ARG1
, keywords
, "#sUU", rest
,
1135 &mode_arg_pos
, &mode
,
1136 &start_arg_pos
, &start
,
1137 &size_arg_pos
, &size
);
1139 scm_dynwind_begin (0);
1142 mode
= xstrdup ("r");
1143 scm_dynwind_free (mode
);
1145 if (size_arg_pos
> 0)
1147 /* For now be strict about start+size overflowing. If it becomes
1148 a nuisance we can relax things later. */
1149 if (start
+ size
< start
)
1151 gdbscm_out_of_range_error (FUNC_NAME
, 0,
1152 scm_list_2 (gdbscm_scm_from_ulongest (start
),
1153 gdbscm_scm_from_ulongest (size
)),
1154 _("start+size overflows"));
1159 end
= ~(CORE_ADDR
) 0;
1161 mode_bits
= ioscm_parse_mode_bits (FUNC_NAME
, mode
);
1163 port
= ioscm_open_port (memory_port_desc
, mode_bits
);
1165 ioscm_init_memory_port (port
, start
, end
);
1169 /* TODO: Set the file name as "memory-start-end"? */
1173 /* Return non-zero if OBJ is a memory port. */
1176 gdbscm_is_memory_port (SCM obj
)
1178 return !SCM_IMP (obj
) && (SCM_TYP16 (obj
) == memory_port_desc
);
1181 /* (memory-port? obj) -> boolean */
1184 gdbscm_memory_port_p (SCM obj
)
1186 return scm_from_bool (gdbscm_is_memory_port (obj
));
1189 /* (memory-port-range port) -> (start end) */
1192 gdbscm_memory_port_range (SCM port
)
1194 ioscm_memory_port
*iomem
;
1196 SCM_ASSERT_TYPE (gdbscm_is_memory_port (port
), port
, SCM_ARG1
, FUNC_NAME
,
1197 memory_port_desc_name
);
1199 iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
1200 return scm_list_2 (gdbscm_scm_from_ulongest (iomem
->start
),
1201 gdbscm_scm_from_ulongest (iomem
->end
));
1204 /* (memory-port-read-buffer-size port) -> integer */
1207 gdbscm_memory_port_read_buffer_size (SCM port
)
1209 ioscm_memory_port
*iomem
;
1211 SCM_ASSERT_TYPE (gdbscm_is_memory_port (port
), port
, SCM_ARG1
, FUNC_NAME
,
1212 memory_port_desc_name
);
1214 iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
1215 return scm_from_uint (iomem
->read_buf_size
);
1218 /* (set-memory-port-read-buffer-size! port size) -> unspecified
1219 An exception is thrown if read data is still buffered or if the port
1223 gdbscm_set_memory_port_read_buffer_size_x (SCM port
, SCM size
)
1225 ioscm_memory_port
*iomem
;
1227 SCM_ASSERT_TYPE (gdbscm_is_memory_port (port
), port
, SCM_ARG1
, FUNC_NAME
,
1228 memory_port_desc_name
);
1229 SCM_ASSERT_TYPE (scm_is_integer (size
), size
, SCM_ARG2
, FUNC_NAME
,
1232 if (!scm_is_unsigned_integer (size
, min_memory_port_buf_size
,
1233 max_memory_port_buf_size
))
1235 gdbscm_out_of_range_error (FUNC_NAME
, SCM_ARG2
, size
,
1236 out_of_range_buf_size
);
1239 iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
1240 ioscm_reinit_memory_port (port
, scm_to_uint (size
), iomem
->write_buf_size
,
1243 return SCM_UNSPECIFIED
;
1246 /* (memory-port-write-buffer-size port) -> integer */
1249 gdbscm_memory_port_write_buffer_size (SCM port
)
1251 ioscm_memory_port
*iomem
;
1253 SCM_ASSERT_TYPE (gdbscm_is_memory_port (port
), port
, SCM_ARG1
, FUNC_NAME
,
1254 memory_port_desc_name
);
1256 iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
1257 return scm_from_uint (iomem
->write_buf_size
);
1260 /* (set-memory-port-write-buffer-size! port size) -> unspecified
1261 An exception is thrown if write data is still buffered or if the port
1265 gdbscm_set_memory_port_write_buffer_size_x (SCM port
, SCM size
)
1267 ioscm_memory_port
*iomem
;
1269 SCM_ASSERT_TYPE (gdbscm_is_memory_port (port
), port
, SCM_ARG1
, FUNC_NAME
,
1270 memory_port_desc_name
);
1271 SCM_ASSERT_TYPE (scm_is_integer (size
), size
, SCM_ARG2
, FUNC_NAME
,
1274 if (!scm_is_unsigned_integer (size
, min_memory_port_buf_size
,
1275 max_memory_port_buf_size
))
1277 gdbscm_out_of_range_error (FUNC_NAME
, SCM_ARG2
, size
,
1278 out_of_range_buf_size
);
1281 iomem
= (ioscm_memory_port
*) SCM_STREAM (port
);
1282 ioscm_reinit_memory_port (port
, iomem
->read_buf_size
, scm_to_uint (size
),
1285 return SCM_UNSPECIFIED
;
1288 /* Initialize gdb ports. */
1290 static const scheme_function port_functions
[] =
1292 { "input-port", 0, 0, 0, as_a_scm_t_subr (gdbscm_input_port
),
1294 Return gdb's input port." },
1296 { "output-port", 0, 0, 0, as_a_scm_t_subr (gdbscm_output_port
),
1298 Return gdb's output port." },
1300 { "error-port", 0, 0, 0, as_a_scm_t_subr (gdbscm_error_port
),
1302 Return gdb's error port." },
1304 { "stdio-port?", 1, 0, 0, as_a_scm_t_subr (gdbscm_stdio_port_p
),
1306 Return #t if the object is a gdb:stdio-port." },
1308 { "open-memory", 0, 0, 1, as_a_scm_t_subr (gdbscm_open_memory
),
1310 Return a port that can be used for reading/writing inferior memory.\n\
1312 Arguments: [#:mode string] [#:start address] [#:size integer]\n\
1313 Returns: A port object." },
1315 { "memory-port?", 1, 0, 0, as_a_scm_t_subr (gdbscm_memory_port_p
),
1317 Return #t if the object is a memory port." },
1319 { "memory-port-range", 1, 0, 0, as_a_scm_t_subr (gdbscm_memory_port_range
),
1321 Return the memory range of the port as (start end)." },
1323 { "memory-port-read-buffer-size", 1, 0, 0,
1324 as_a_scm_t_subr (gdbscm_memory_port_read_buffer_size
),
1326 Return the size of the read buffer for the memory port." },
1328 { "set-memory-port-read-buffer-size!", 2, 0, 0,
1329 as_a_scm_t_subr (gdbscm_set_memory_port_read_buffer_size_x
),
1331 Set the size of the read buffer for the memory port.\n\
1333 Arguments: port integer\n\
1334 Returns: unspecified." },
1336 { "memory-port-write-buffer-size", 1, 0, 0,
1337 as_a_scm_t_subr (gdbscm_memory_port_write_buffer_size
),
1339 Return the size of the write buffer for the memory port." },
1341 { "set-memory-port-write-buffer-size!", 2, 0, 0,
1342 as_a_scm_t_subr (gdbscm_set_memory_port_write_buffer_size_x
),
1344 Set the size of the write buffer for the memory port.\n\
1346 Arguments: port integer\n\
1347 Returns: unspecified." },
1352 static const scheme_function private_port_functions
[] =
1355 { "%with-gdb-input-from-port", 2, 0, 0,
1356 as_a_scm_t_subr (gdbscm_percent_with_gdb_input_from_port
),
1358 Temporarily set GDB's input port to PORT and then invoke THUNK.\n\
1360 Arguments: port thunk\n\
1361 Returns: The result of calling THUNK.\n\
1363 This procedure is experimental." },
1366 { "%with-gdb-output-to-port", 2, 0, 0,
1367 as_a_scm_t_subr (gdbscm_percent_with_gdb_output_to_port
),
1369 Temporarily set GDB's output port to PORT and then invoke THUNK.\n\
1371 Arguments: port thunk\n\
1372 Returns: The result of calling THUNK.\n\
1374 This procedure is experimental." },
1376 { "%with-gdb-error-to-port", 2, 0, 0,
1377 as_a_scm_t_subr (gdbscm_percent_with_gdb_error_to_port
),
1379 Temporarily set GDB's error port to PORT and then invoke THUNK.\n\
1381 Arguments: port thunk\n\
1382 Returns: The result of calling THUNK.\n\
1384 This procedure is experimental." },
1390 gdbscm_initialize_ports (void)
1392 /* Save the original stdio ports for debugging purposes. */
1394 orig_input_port_scm
= scm_current_input_port ();
1395 orig_output_port_scm
= scm_current_output_port ();
1396 orig_error_port_scm
= scm_current_error_port ();
1398 /* Set up the stdio ports. */
1400 ioscm_init_gdb_stdio_port ();
1401 input_port_scm
= ioscm_make_gdb_stdio_port (0);
1402 output_port_scm
= ioscm_make_gdb_stdio_port (1);
1403 error_port_scm
= ioscm_make_gdb_stdio_port (2);
1405 /* Set up memory ports. */
1407 ioscm_init_memory_port_type ();
1409 /* Install the accessor functions. */
1411 gdbscm_define_functions (port_functions
, 1);
1412 gdbscm_define_functions (private_port_functions
, 0);
1414 /* Keyword args for open-memory. */
1416 mode_keyword
= scm_from_latin1_keyword ("mode");
1417 start_keyword
= scm_from_latin1_keyword ("start");
1418 size_keyword
= scm_from_latin1_keyword ("size");
1420 /* Error message text for "out of range" memory port buffer sizes. */
1422 out_of_range_buf_size
= xstrprintf ("size not between %u - %u",
1423 min_memory_port_buf_size
,
1424 max_memory_port_buf_size
);