diff --git a/gdb/guile/guile-internal.h b/gdb/guile/guile-internal.h
index 509120b..ca5f1c0 100644
--- a/gdb/guile/guile-internal.h
+++ b/gdb/guile/guile-internal.h
@@ -50,6 +50,50 @@ typedef struct
 
 #define END_VARIABLES { NULL, SCM_BOOL_F, NULL }
 
+#ifdef __cplusplus
+
+/* Although scm_t_subr is meant to hold a function pointer, at least
+   in some versions of guile, it is actually a typedef to "void *".
+   That means that in C++, an explicit cast is necessary to convert
+   function pointer to scm_t_subr.  But a cast also makes it possible
+   to pass function pointers with the wrong type by mistake.  So
+   instead of adding such casts throughout, we use 'as_a_scm_t_subr'
+   to do the conversion, which (only) has overloads for function
+   pointer types that are valid.
+
+   See https://lists.gnu.org/archive/html/guile-devel/2013-03/msg00001.html.
+*/
+
+static inline scm_t_subr
+as_a_scm_t_subr (SCM (*func) (void))
+{
+  return (scm_t_subr) func;
+}
+
+static inline scm_t_subr
+as_a_scm_t_subr (SCM (*func) (SCM))
+{
+  return (scm_t_subr) func;
+}
+
+static inline scm_t_subr
+as_a_scm_t_subr (SCM (*func) (SCM, SCM))
+{
+  return (scm_t_subr) func;
+}
+
+static inline scm_t_subr
+as_a_scm_t_subr (SCM (*func) (SCM, SCM, SCM))
+{
+  return (scm_t_subr) func;
+}
+
+#else
+
+/* In C, just do an implicit conversion.  */
+#define as_a_scm_t_subr(func) func
+
+#endif
 /* Scheme functions to define during initialization.  */
 
 typedef struct
diff --git a/gdb/guile/guile.c b/gdb/guile/guile.c
index 4abf5c5..2eb6dc6 100644
--- a/gdb/guile/guile.c
+++ b/gdb/guile/guile.c
@@ -478,7 +478,7 @@ info_guile_command (char *args, int from_tty)
 
 static const scheme_function misc_guile_functions[] =
 {
-  { "execute", 1, 0, 1, gdbscm_execute_gdb_command,
+  { "execute", 1, 0, 1, as_a_scm_t_subr (gdbscm_execute_gdb_command),
   "\
 Execute the given GDB command.\n\
 \n\
@@ -491,23 +491,24 @@ Execute the given GDB command.\n\
   Returns: The result of the command if #:to-string is true.\n\
     Otherwise returns unspecified." },
 
-  { "data-directory", 0, 0, 0, gdbscm_data_directory,
+  { "data-directory", 0, 0, 0, as_a_scm_t_subr (gdbscm_data_directory),
     "\
 Return the name of GDB's data directory." },
 
-  { "guile-data-directory", 0, 0, 0, gdbscm_guile_data_directory,
+  { "guile-data-directory", 0, 0, 0,
+    as_a_scm_t_subr (gdbscm_guile_data_directory),
     "\
 Return the name of the Guile directory within GDB's data directory." },
 
-  { "gdb-version", 0, 0, 0, gdbscm_gdb_version,
+  { "gdb-version", 0, 0, 0, as_a_scm_t_subr (gdbscm_gdb_version),
     "\
 Return GDB's version string." },
 
-  { "host-config", 0, 0, 0, gdbscm_host_config,
+  { "host-config", 0, 0, 0, as_a_scm_t_subr (gdbscm_host_config),
     "\
 Return the name of the host configuration." },
 
-  { "target-config", 0, 0, 0, gdbscm_target_config,
+  { "target-config", 0, 0, 0, as_a_scm_t_subr (gdbscm_target_config),
     "\
 Return the name of the target configuration." },
 
diff --git a/gdb/guile/scm-arch.c b/gdb/guile/scm-arch.c
index a606de2..9a1a922 100644
--- a/gdb/guile/scm-arch.c
+++ b/gdb/guile/scm-arch.c
@@ -495,11 +495,11 @@ gdbscm_arch_uint64_type (SCM self)
 
 static const scheme_function arch_functions[] =
 {
-  { "arch?", 1, 0, 0, gdbscm_arch_p,
+  { "arch?", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_p),
     "\
 Return #t if the object is a <gdb:arch> object." },
 
-  { "current-arch", 0, 0, 0, gdbscm_current_arch,
+  { "current-arch", 0, 0, 0, as_a_scm_t_subr (gdbscm_current_arch),
     "\
 Return the <gdb:arch> object representing the architecture of the\n\
 currently selected stack frame, if there is one, or the architecture of the\n\
@@ -507,135 +507,136 @@ current target if there isn't.\n\
 \n\
   Arguments: none" },
 
-  { "arch-name", 1, 0, 0, gdbscm_arch_name,
+  { "arch-name", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_name),
     "\
 Return the name of the architecture." },
 
-  { "arch-charset", 1, 0, 0, gdbscm_arch_charset,
+  { "arch-charset", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_charset),
   "\
 Return name of target character set as a string." },
 
-  { "arch-wide-charset", 1, 0, 0, gdbscm_arch_wide_charset,
+  { "arch-wide-charset", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_wide_charset),
   "\
 Return name of target wide character set as a string." },
 
-  { "arch-void-type", 1, 0, 0, gdbscm_arch_void_type,
+  { "arch-void-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_void_type),
     "\
 Return the <gdb:type> object for the \"void\" type\n\
 of the architecture." },
 
-  { "arch-char-type", 1, 0, 0, gdbscm_arch_char_type,
+  { "arch-char-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_char_type),
     "\
 Return the <gdb:type> object for the \"char\" type\n\
 of the architecture." },
 
-  { "arch-short-type", 1, 0, 0, gdbscm_arch_short_type,
+  { "arch-short-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_short_type),
     "\
 Return the <gdb:type> object for the \"short\" type\n\
 of the architecture." },
 
-  { "arch-int-type", 1, 0, 0, gdbscm_arch_int_type,
+  { "arch-int-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_int_type),
     "\
 Return the <gdb:type> object for the \"int\" type\n\
 of the architecture." },
 
-  { "arch-long-type", 1, 0, 0, gdbscm_arch_long_type,
+  { "arch-long-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_long_type),
     "\
 Return the <gdb:type> object for the \"long\" type\n\
 of the architecture." },
 
-  { "arch-schar-type", 1, 0, 0, gdbscm_arch_schar_type,
+  { "arch-schar-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_schar_type),
     "\
 Return the <gdb:type> object for the \"signed char\" type\n\
 of the architecture." },
 
-  { "arch-uchar-type", 1, 0, 0, gdbscm_arch_uchar_type,
+  { "arch-uchar-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_uchar_type),
     "\
 Return the <gdb:type> object for the \"unsigned char\" type\n\
 of the architecture." },
 
-  { "arch-ushort-type", 1, 0, 0, gdbscm_arch_ushort_type,
+  { "arch-ushort-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_ushort_type),
     "\
 Return the <gdb:type> object for the \"unsigned short\" type\n\
 of the architecture." },
 
-  { "arch-uint-type", 1, 0, 0, gdbscm_arch_uint_type,
+  { "arch-uint-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_uint_type),
     "\
 Return the <gdb:type> object for the \"unsigned int\" type\n\
 of the architecture." },
 
-  { "arch-ulong-type", 1, 0, 0, gdbscm_arch_ulong_type,
+  { "arch-ulong-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_ulong_type),
     "\
 Return the <gdb:type> object for the \"unsigned long\" type\n\
 of the architecture." },
 
-  { "arch-float-type", 1, 0, 0, gdbscm_arch_float_type,
+  { "arch-float-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_float_type),
     "\
 Return the <gdb:type> object for the \"float\" type\n\
 of the architecture." },
 
-  { "arch-double-type", 1, 0, 0, gdbscm_arch_double_type,
+  { "arch-double-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_double_type),
     "\
 Return the <gdb:type> object for the \"double\" type\n\
 of the architecture." },
 
-  { "arch-longdouble-type", 1, 0, 0, gdbscm_arch_longdouble_type,
+  { "arch-longdouble-type", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_arch_longdouble_type),
     "\
 Return the <gdb:type> object for the \"long double\" type\n\
 of the architecture." },
 
-  { "arch-bool-type", 1, 0, 0, gdbscm_arch_bool_type,
+  { "arch-bool-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_bool_type),
     "\
 Return the <gdb:type> object for the \"bool\" type\n\
 of the architecture." },
 
-  { "arch-longlong-type", 1, 0, 0, gdbscm_arch_longlong_type,
+  { "arch-longlong-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_longlong_type),
     "\
 Return the <gdb:type> object for the \"long long\" type\n\
 of the architecture." },
 
   { "arch-ulonglong-type", 1, 0, 0,
-    gdbscm_arch_ulonglong_type,
+    as_a_scm_t_subr (gdbscm_arch_ulonglong_type),
     "\
 Return the <gdb:type> object for the \"unsigned long long\" type\n\
 of the architecture." },
 
-  { "arch-int8-type", 1, 0, 0, gdbscm_arch_int8_type,
+  { "arch-int8-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_int8_type),
     "\
 Return the <gdb:type> object for the \"int8\" type\n\
 of the architecture." },
 
-  { "arch-uint8-type", 1, 0, 0, gdbscm_arch_uint8_type,
+  { "arch-uint8-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_uint8_type),
     "\
 Return the <gdb:type> object for the \"uint8\" type\n\
 of the architecture." },
 
-  { "arch-int16-type", 1, 0, 0, gdbscm_arch_int16_type,
+  { "arch-int16-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_int16_type),
     "\
 Return the <gdb:type> object for the \"int16\" type\n\
 of the architecture." },
 
-  { "arch-uint16-type", 1, 0, 0, gdbscm_arch_uint16_type,
+  { "arch-uint16-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_uint16_type),
     "\
 Return the <gdb:type> object for the \"uint16\" type\n\
 of the architecture." },
 
-  { "arch-int32-type", 1, 0, 0, gdbscm_arch_int32_type,
+  { "arch-int32-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_int32_type),
     "\
 Return the <gdb:type> object for the \"int32\" type\n\
 of the architecture." },
 
-  { "arch-uint32-type", 1, 0, 0, gdbscm_arch_uint32_type,
+  { "arch-uint32-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_uint32_type),
     "\
 Return the <gdb:type> object for the \"uint32\" type\n\
 of the architecture." },
 
-  { "arch-int64-type", 1, 0, 0, gdbscm_arch_int64_type,
+  { "arch-int64-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_int64_type),
     "\
 Return the <gdb:type> object for the \"int64\" type\n\
 of the architecture." },
 
-  { "arch-uint64-type", 1, 0, 0, gdbscm_arch_uint64_type,
+  { "arch-uint64-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_arch_uint64_type),
     "\
 Return the <gdb:type> object for the \"uint64\" type\n\
 of the architecture." },
diff --git a/gdb/guile/scm-block.c b/gdb/guile/scm-block.c
index 50dc6c7..c4b367f 100644
--- a/gdb/guile/scm-block.c
+++ b/gdb/guile/scm-block.c
@@ -709,61 +709,63 @@ gdbscm_lookup_block (SCM pc_scm)
 
 static const scheme_function block_functions[] =
 {
-  { "block?", 1, 0, 0, gdbscm_block_p,
+  { "block?", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_p),
     "\
 Return #t if the object is a <gdb:block> object." },
 
-  { "block-valid?", 1, 0, 0, gdbscm_block_valid_p,
+  { "block-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_valid_p),
     "\
 Return #t if the block is valid.\n\
 A block becomes invalid when its objfile is freed." },
 
-  { "block-start", 1, 0, 0, gdbscm_block_start,
+  { "block-start", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_start),
     "\
 Return the start address of the block." },
 
-  { "block-end", 1, 0, 0, gdbscm_block_end,
+  { "block-end", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_end),
     "\
 Return the end address of the block." },
 
-  { "block-function", 1, 0, 0, gdbscm_block_function,
+  { "block-function", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_function),
     "\
 Return the gdb:symbol object of the function containing the block\n\
 or #f if the block does not live in any function." },
 
-  { "block-superblock", 1, 0, 0, gdbscm_block_superblock,
+  { "block-superblock", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_superblock),
     "\
 Return the superblock (parent block) of the block." },
 
-  { "block-global-block", 1, 0, 0, gdbscm_block_global_block,
+  { "block-global-block", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_global_block),
     "\
 Return the global block of the block." },
 
-  { "block-static-block", 1, 0, 0, gdbscm_block_static_block,
+  { "block-static-block", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_static_block),
     "\
 Return the static block of the block." },
 
-  { "block-global?", 1, 0, 0, gdbscm_block_global_p,
+  { "block-global?", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_global_p),
     "\
 Return #t if block is a global block." },
 
-  { "block-static?", 1, 0, 0, gdbscm_block_static_p,
+  { "block-static?", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_static_p),
     "\
 Return #t if block is a static block." },
 
-  { "block-symbols", 1, 0, 0, gdbscm_block_symbols,
+  { "block-symbols", 1, 0, 0, as_a_scm_t_subr (gdbscm_block_symbols),
     "\
 Return a list of all symbols (as <gdb:symbol> objects) in the block." },
 
-  { "make-block-symbols-iterator", 1, 0, 0, gdbscm_make_block_syms_iter,
+  { "make-block-symbols-iterator", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_make_block_syms_iter),
     "\
 Return a <gdb:iterator> object for iterating over all symbols in the block." },
 
-  { "block-symbols-progress?", 1, 0, 0, bkscm_block_syms_progress_p,
+  { "block-symbols-progress?", 1, 0, 0,
+    as_a_scm_t_subr (bkscm_block_syms_progress_p),
     "\
 Return #t if the object is a <gdb:block-symbols-progress> object." },
 
-  { "lookup-block", 1, 0, 0, gdbscm_lookup_block,
+  { "lookup-block", 1, 0, 0, as_a_scm_t_subr (gdbscm_lookup_block),
     "\
 Return the innermost GDB block containing the address or #f if none found.\n\
 \n\
@@ -792,7 +794,7 @@ gdbscm_initialize_blocks (void)
   /* This function is "private".  */
   bkscm_next_symbol_x_proc
     = scm_c_define_gsubr ("%block-next-symbol!", 1, 0, 0,
-			  gdbscm_block_next_symbol_x);
+			  as_a_scm_t_subr (gdbscm_block_next_symbol_x));
   scm_set_procedure_property_x (bkscm_next_symbol_x_proc,
 				gdbscm_documentation_symbol,
 				gdbscm_scm_from_c_string ("\
diff --git a/gdb/guile/scm-breakpoint.c b/gdb/guile/scm-breakpoint.c
index a7e0fe0..eea9b46 100644
--- a/gdb/guile/scm-breakpoint.c
+++ b/gdb/guile/scm-breakpoint.c
@@ -1169,7 +1169,7 @@ static const scheme_integer_constant breakpoint_integer_constants[] =
 
 static const scheme_function breakpoint_functions[] =
 {
-  { "make-breakpoint", 1, 0, 1, gdbscm_make_breakpoint,
+  { "make-breakpoint", 1, 0, 1, as_a_scm_t_subr (gdbscm_make_breakpoint),
     "\
 Create a GDB breakpoint object.\n\
 \n\
@@ -1178,128 +1178,142 @@ Create a GDB breakpoint object.\n\
   Returns:\n\
     <gdb:breakpoint object" },
 
-  { "register-breakpoint!", 1, 0, 0, gdbscm_register_breakpoint_x,
+  { "register-breakpoint!", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_register_breakpoint_x),
     "\
 Register a <gdb:breakpoint> object with GDB." },
 
-  { "delete-breakpoint!", 1, 0, 0, gdbscm_delete_breakpoint_x,
+  { "delete-breakpoint!", 1, 0, 0, as_a_scm_t_subr (gdbscm_delete_breakpoint_x),
     "\
 Delete the breakpoint from GDB." },
 
-  { "breakpoints", 0, 0, 0, gdbscm_breakpoints,
+  { "breakpoints", 0, 0, 0, as_a_scm_t_subr (gdbscm_breakpoints),
     "\
 Return a list of all GDB breakpoints.\n\
 \n\
   Arguments: none" },
 
-  { "breakpoint?", 1, 0, 0, gdbscm_breakpoint_p,
+  { "breakpoint?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_p),
     "\
 Return #t if the object is a <gdb:breakpoint> object." },
 
-  { "breakpoint-valid?", 1, 0, 0, gdbscm_breakpoint_valid_p,
+  { "breakpoint-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_valid_p),
     "\
 Return #t if the breakpoint has not been deleted from GDB." },
 
-  { "breakpoint-number", 1, 0, 0, gdbscm_breakpoint_number,
+  { "breakpoint-number", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_number),
     "\
 Return the breakpoint's number." },
 
-  { "breakpoint-type", 1, 0, 0, gdbscm_breakpoint_type,
+  { "breakpoint-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_type),
     "\
 Return the type of the breakpoint." },
 
-  { "breakpoint-visible?", 1, 0, 0, gdbscm_breakpoint_visible,
+  { "breakpoint-visible?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_visible),
     "\
 Return #t if the breakpoint is visible to the user." },
 
-  { "breakpoint-location", 1, 0, 0, gdbscm_breakpoint_location,
+  { "breakpoint-location", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_breakpoint_location),
     "\
 Return the location of the breakpoint as specified by the user." },
 
-  { "breakpoint-expression", 1, 0, 0, gdbscm_breakpoint_expression,
+  { "breakpoint-expression", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_breakpoint_expression),
     "\
 Return the expression of the breakpoint as specified by the user.\n\
 Valid for watchpoints only, returns #f for non-watchpoints." },
 
-  { "breakpoint-enabled?", 1, 0, 0, gdbscm_breakpoint_enabled_p,
+  { "breakpoint-enabled?", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_breakpoint_enabled_p),
     "\
 Return #t if the breakpoint is enabled." },
 
-  { "set-breakpoint-enabled!", 2, 0, 0, gdbscm_set_breakpoint_enabled_x,
+  { "set-breakpoint-enabled!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_breakpoint_enabled_x),
     "\
 Set the breakpoint's enabled state.\n\
 \n\
   Arguments: <gdb:breakpoint> boolean" },
 
-  { "breakpoint-silent?", 1, 0, 0, gdbscm_breakpoint_silent_p,
+  { "breakpoint-silent?", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_silent_p),
     "\
 Return #t if the breakpoint is silent." },
 
-  { "set-breakpoint-silent!", 2, 0, 0, gdbscm_set_breakpoint_silent_x,
+  { "set-breakpoint-silent!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_breakpoint_silent_x),
     "\
 Set the breakpoint's silent state.\n\
 \n\
   Arguments: <gdb:breakpoint> boolean" },
 
-  { "breakpoint-ignore-count", 1, 0, 0, gdbscm_breakpoint_ignore_count,
+  { "breakpoint-ignore-count", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_breakpoint_ignore_count),
     "\
 Return the breakpoint's \"ignore\" count." },
 
   { "set-breakpoint-ignore-count!", 2, 0, 0,
-    gdbscm_set_breakpoint_ignore_count_x,
+    as_a_scm_t_subr (gdbscm_set_breakpoint_ignore_count_x),
     "\
 Set the breakpoint's \"ignore\" count.\n\
 \n\
   Arguments: <gdb:breakpoint> count" },
 
-  { "breakpoint-hit-count", 1, 0, 0, gdbscm_breakpoint_hit_count,
+  { "breakpoint-hit-count", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_breakpoint_hit_count),
     "\
 Return the breakpoint's \"hit\" count." },
 
-  { "set-breakpoint-hit-count!", 2, 0, 0, gdbscm_set_breakpoint_hit_count_x,
+  { "set-breakpoint-hit-count!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_breakpoint_hit_count_x),
     "\
 Set the breakpoint's \"hit\" count.  The value must be zero.\n\
 \n\
   Arguments: <gdb:breakpoint> 0" },
 
-  { "breakpoint-thread", 1, 0, 0, gdbscm_breakpoint_thread,
+  { "breakpoint-thread", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_thread),
     "\
 Return the breakpoint's thread id or #f if there isn't one." },
 
-  { "set-breakpoint-thread!", 2, 0, 0, gdbscm_set_breakpoint_thread_x,
+  { "set-breakpoint-thread!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_breakpoint_thread_x),
     "\
 Set the thread id for this breakpoint.\n\
 \n\
   Arguments: <gdb:breakpoint> thread-id" },
 
-  { "breakpoint-task", 1, 0, 0, gdbscm_breakpoint_task,
+  { "breakpoint-task", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_task),
     "\
 Return the breakpoint's Ada task-id or #f if there isn't one." },
 
-  { "set-breakpoint-task!", 2, 0, 0, gdbscm_set_breakpoint_task_x,
+  { "set-breakpoint-task!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_breakpoint_task_x),
     "\
 Set the breakpoint's Ada task-id.\n\
 \n\
   Arguments: <gdb:breakpoint> task-id" },
 
-  { "breakpoint-condition", 1, 0, 0, gdbscm_breakpoint_condition,
+  { "breakpoint-condition", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_breakpoint_condition),
     "\
 Return the breakpoint's condition as specified by the user.\n\
 Return #f if there isn't one." },
 
-  { "set-breakpoint-condition!", 2, 0, 0, gdbscm_set_breakpoint_condition_x,
+  { "set-breakpoint-condition!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_breakpoint_condition_x),
     "\
 Set the breakpoint's condition.\n\
 \n\
   Arguments: <gdb:breakpoint> condition\n\
     condition: a string" },
 
-  { "breakpoint-stop", 1, 0, 0, gdbscm_breakpoint_stop,
+  { "breakpoint-stop", 1, 0, 0, as_a_scm_t_subr (gdbscm_breakpoint_stop),
     "\
 Return the breakpoint's stop predicate.\n\
 Return #f if there isn't one." },
 
-  { "set-breakpoint-stop!", 2, 0, 0, gdbscm_set_breakpoint_stop_x,
+  { "set-breakpoint-stop!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_breakpoint_stop_x),
     "\
 Set the breakpoint's stop predicate.\n\
 \n\
@@ -1307,7 +1321,8 @@ Set the breakpoint's stop predicate.\n\
     procedure: A procedure of one argument, the breakpoint.\n\
       Its result is true if program execution should stop." },
 
-  { "breakpoint-commands", 1, 0, 0, gdbscm_breakpoint_commands,
+  { "breakpoint-commands", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_breakpoint_commands),
     "\
 Return the breakpoint's commands." },
 
diff --git a/gdb/guile/scm-cmd.c b/gdb/guile/scm-cmd.c
index 4477b98..e782648 100644
--- a/gdb/guile/scm-cmd.c
+++ b/gdb/guile/scm-cmd.c
@@ -819,7 +819,7 @@ gdbscm_register_command_x (SCM self)
 
 static const scheme_function command_functions[] =
 {
-  { "make-command", 1, 0, 1, gdbscm_make_command,
+  { "make-command", 1, 0, 1, as_a_scm_t_subr (gdbscm_make_command),
     "\
 Make a GDB command object.\n\
 \n\
@@ -840,19 +840,19 @@ Make a GDB command object.\n\
     doc: The \"doc string\" of the command.\n\
   Returns: <gdb:command> object" },
 
-  { "register-command!", 1, 0, 0, gdbscm_register_command_x,
+  { "register-command!", 1, 0, 0, as_a_scm_t_subr (gdbscm_register_command_x),
     "\
 Register a <gdb:command> object with GDB." },
 
-  { "command?", 1, 0, 0, gdbscm_command_p,
+  { "command?", 1, 0, 0, as_a_scm_t_subr (gdbscm_command_p),
     "\
 Return #t if the object is a <gdb:command> object." },
 
-  { "command-valid?", 1, 0, 0, gdbscm_command_valid_p,
+  { "command-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_command_valid_p),
     "\
 Return #t if the <gdb:command> object is valid." },
 
-  { "dont-repeat", 1, 0, 0, gdbscm_dont_repeat,
+  { "dont-repeat", 1, 0, 0, as_a_scm_t_subr (gdbscm_dont_repeat),
     "\
 Prevent command repetition when user enters an empty line.\n\
 \n\
diff --git a/gdb/guile/scm-disasm.c b/gdb/guile/scm-disasm.c
index 782d915..fe37a38 100644
--- a/gdb/guile/scm-disasm.c
+++ b/gdb/guile/scm-disasm.c
@@ -318,7 +318,7 @@ gdbscm_arch_disassemble (SCM self, SCM start_scm, SCM rest)
 
 static const scheme_function disasm_functions[] =
 {
-  { "arch-disassemble", 2, 0, 1, gdbscm_arch_disassemble,
+  { "arch-disassemble", 2, 0, 1, as_a_scm_t_subr (gdbscm_arch_disassemble),
     "\
 Return list of disassembled instructions in memory.\n\
 \n\
diff --git a/gdb/guile/scm-exception.c b/gdb/guile/scm-exception.c
index 73dfb84..ae591cb 100644
--- a/gdb/guile/scm-exception.c
+++ b/gdb/guile/scm-exception.c
@@ -635,22 +635,22 @@ gdbscm_percent_exception_count (void)
 
 static const scheme_function exception_functions[] =
 {
-  { "make-exception", 2, 0, 0, gdbscm_make_exception,
+  { "make-exception", 2, 0, 0, as_a_scm_t_subr (gdbscm_make_exception),
     "\
 Create a <gdb:exception> object.\n\
 \n\
   Arguments: key args\n\
     These are the standard key,args arguments of \"throw\"." },
 
-  { "exception?", 1, 0, 0, gdbscm_exception_p,
+  { "exception?", 1, 0, 0, as_a_scm_t_subr (gdbscm_exception_p),
     "\
 Return #t if the object is a <gdb:exception> object." },
 
-  { "exception-key", 1, 0, 0, gdbscm_exception_key,
+  { "exception-key", 1, 0, 0, as_a_scm_t_subr (gdbscm_exception_key),
     "\
 Return the exception's key." },
 
-  { "exception-args", 1, 0, 0, gdbscm_exception_args,
+  { "exception-args", 1, 0, 0, as_a_scm_t_subr (gdbscm_exception_args),
     "\
 Return the exception's arg list." },
 
@@ -659,11 +659,13 @@ Return the exception's arg list." },
 
 static const scheme_function private_exception_functions[] =
 {
-  { "%exception-print-style", 0, 0, 0, gdbscm_percent_exception_print_style,
+  { "%exception-print-style", 0, 0, 0,
+    as_a_scm_t_subr (gdbscm_percent_exception_print_style),
     "\
 Return the value of the \"guile print-stack\" option." },
 
-  { "%exception-count", 0, 0, 0, gdbscm_percent_exception_count,
+  { "%exception-count", 0, 0, 0,
+    as_a_scm_t_subr (gdbscm_percent_exception_count),
     "\
 Return a count of the number of <gdb:exception> objects created.\n\
 This is for debugging purposes." },
diff --git a/gdb/guile/scm-frame.c b/gdb/guile/scm-frame.c
index de77c21..38e1448 100644
--- a/gdb/guile/scm-frame.c
+++ b/gdb/guile/scm-frame.c
@@ -1075,86 +1075,89 @@ static const scheme_integer_constant frame_integer_constants[] =
 
 static const scheme_function frame_functions[] =
 {
-  { "frame?", 1, 0, 0, gdbscm_frame_p,
+  { "frame?", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_p),
     "\
 Return #t if the object is a <gdb:frame> object." },
 
-  { "frame-valid?", 1, 0, 0, gdbscm_frame_valid_p,
+  { "frame-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_valid_p),
     "\
 Return #t if the object is a valid <gdb:frame> object.\n\
 Frames become invalid when the inferior returns to its caller." },
 
-  { "frame-name", 1, 0, 0, gdbscm_frame_name,
+  { "frame-name", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_name),
     "\
 Return the name of the function corresponding to this frame,\n\
 or #f if there is no function." },
 
-  { "frame-arch", 1, 0, 0, gdbscm_frame_arch,
+  { "frame-arch", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_arch),
     "\
 Return the frame's architecture as a <gdb:arch> object." },
 
-  { "frame-type", 1, 0, 0, gdbscm_frame_type,
+  { "frame-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_type),
     "\
 Return the frame type, namely one of the gdb:*_FRAME constants." },
 
-  { "frame-unwind-stop-reason", 1, 0, 0, gdbscm_frame_unwind_stop_reason,
+  { "frame-unwind-stop-reason", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_frame_unwind_stop_reason),
     "\
 Return one of the gdb:FRAME_UNWIND_* constants explaining why\n\
 it's not possible to find frames older than this." },
 
-  { "frame-pc", 1, 0, 0, gdbscm_frame_pc,
+  { "frame-pc", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_pc),
     "\
 Return the frame's resume address." },
 
-  { "frame-block", 1, 0, 0, gdbscm_frame_block,
+  { "frame-block", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_block),
     "\
 Return the frame's code block, or #f if one cannot be found." },
 
-  { "frame-function", 1, 0, 0, gdbscm_frame_function,
+  { "frame-function", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_function),
     "\
 Return the <gdb:symbol> for the function corresponding to this frame,\n\
 or #f if there isn't one." },
 
-  { "frame-older", 1, 0, 0, gdbscm_frame_older,
+  { "frame-older", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_older),
     "\
 Return the frame immediately older (outer) to this frame,\n\
 or #f if there isn't one." },
 
-  { "frame-newer", 1, 0, 0, gdbscm_frame_newer,
+  { "frame-newer", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_newer),
     "\
 Return the frame immediately newer (inner) to this frame,\n\
 or #f if there isn't one." },
 
-  { "frame-sal", 1, 0, 0, gdbscm_frame_sal,
+  { "frame-sal", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_sal),
     "\
 Return the frame's symtab-and-line <gdb:sal> object." },
 
-  { "frame-read-var", 2, 0, 1, gdbscm_frame_read_var,
+  { "frame-read-var", 2, 0, 1, as_a_scm_t_subr (gdbscm_frame_read_var),
     "\
 Return the value of the symbol in the frame.\n\
 \n\
   Arguments: <gdb:frame> <gdb:symbol>\n\
          Or: <gdb:frame> string [#:block <gdb:block>]" },
 
-  { "frame-read-register", 2, 0, 0, gdbscm_frame_read_register,
+  { "frame-read-register", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_frame_read_register),
     "\
 Return the value of the register in the frame.\n\
 \n\
   Arguments: <gdb:frame> string" },
 
-  { "frame-select", 1, 0, 0, gdbscm_frame_select,
+  { "frame-select", 1, 0, 0, as_a_scm_t_subr (gdbscm_frame_select),
     "\
 Select this frame." },
 
-  { "newest-frame", 0, 0, 0, gdbscm_newest_frame,
+  { "newest-frame", 0, 0, 0, as_a_scm_t_subr (gdbscm_newest_frame),
     "\
 Return the newest frame." },
 
-  { "selected-frame", 0, 0, 0, gdbscm_selected_frame,
+  { "selected-frame", 0, 0, 0, as_a_scm_t_subr (gdbscm_selected_frame),
     "\
 Return the selected frame." },
 
-  { "unwind-stop-reason-string", 1, 0, 0, gdbscm_unwind_stop_reason_string,
+  { "unwind-stop-reason-string", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_unwind_stop_reason_string),
     "\
 Return a string explaining the unwind stop reason.\n\
 \n\
diff --git a/gdb/guile/scm-gsmob.c b/gdb/guile/scm-gsmob.c
index cff22af..52368e9 100644
--- a/gdb/guile/scm-gsmob.c
+++ b/gdb/guile/scm-gsmob.c
@@ -275,7 +275,7 @@ static const scheme_function gsmob_functions[] =
   /* N.B. There is a general rule of not naming symbols in gdb-guile with a
      "gdb" prefix.  This symbol does not violate this rule because it is to
      be read as "gdb-object-foo", not "gdb-foo".  */
-  { "gdb-object-kind", 1, 0, 0, gdbscm_gsmob_kind,
+  { "gdb-object-kind", 1, 0, 0, as_a_scm_t_subr (gdbscm_gsmob_kind),
     "\
 Return the kind of the GDB object, e.g., <gdb:breakpoint>, as a symbol." },
 
diff --git a/gdb/guile/scm-iterator.c b/gdb/guile/scm-iterator.c
index 46787a2..5a61436 100644
--- a/gdb/guile/scm-iterator.c
+++ b/gdb/guile/scm-iterator.c
@@ -301,7 +301,7 @@ gdbscm_iterator_next_x (SCM self)
 
 static const scheme_function iterator_functions[] =
 {
-  { "make-iterator", 3, 0, 0, gdbscm_make_iterator,
+  { "make-iterator", 3, 0, 0, as_a_scm_t_subr (gdbscm_make_iterator),
     "\
 Create a <gdb:iterator> object.\n\
 \n\
@@ -314,31 +314,32 @@ Create a <gdb:iterator> object.\n\
       By convention end-of-iteration should be marked with (end-of-iteration)\n\
       from module (gdb iterator)." },
 
-  { "iterator?", 1, 0, 0, gdbscm_iterator_p,
+  { "iterator?", 1, 0, 0, as_a_scm_t_subr (gdbscm_iterator_p),
     "\
 Return #t if the object is a <gdb:iterator> object." },
 
-  { "iterator-object", 1, 0, 0, gdbscm_iterator_object,
+  { "iterator-object", 1, 0, 0, as_a_scm_t_subr (gdbscm_iterator_object),
     "\
 Return the object being iterated over." },
 
-  { "iterator-progress", 1, 0, 0, gdbscm_iterator_progress,
+  { "iterator-progress", 1, 0, 0, as_a_scm_t_subr (gdbscm_iterator_progress),
     "\
 Return the progress object of the iterator." },
 
-  { "set-iterator-progress!", 2, 0, 0, gdbscm_set_iterator_progress_x,
+  { "set-iterator-progress!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_iterator_progress_x),
     "\
 Set the progress object of the iterator." },
 
-  { "iterator-next!", 1, 0, 0, gdbscm_iterator_next_x,
+  { "iterator-next!", 1, 0, 0, as_a_scm_t_subr (gdbscm_iterator_next_x),
     "\
 Invoke the next! procedure of the iterator and return its result." },
 
-  { "end-of-iteration", 0, 0, 0, gdbscm_end_of_iteration,
+  { "end-of-iteration", 0, 0, 0, as_a_scm_t_subr (gdbscm_end_of_iteration),
     "\
 Return the end-of-iteration marker." },
 
-  { "end-of-iteration?", 1, 0, 0, gdbscm_end_of_iteration_p,
+  { "end-of-iteration?", 1, 0, 0, as_a_scm_t_subr (gdbscm_end_of_iteration_p),
     "\
 Return #t if the object is the end-of-iteration marker." },
 
diff --git a/gdb/guile/scm-lazy-string.c b/gdb/guile/scm-lazy-string.c
index c84ead7..55c478c 100644
--- a/gdb/guile/scm-lazy-string.c
+++ b/gdb/guile/scm-lazy-string.c
@@ -321,29 +321,32 @@ lsscm_val_print_lazy_string (SCM string, struct ui_file *stream,
 
 static const scheme_function lazy_string_functions[] =
 {
-  { "lazy-string?", 1, 0, 0, gdbscm_lazy_string_p,
+  { "lazy-string?", 1, 0, 0, as_a_scm_t_subr (gdbscm_lazy_string_p),
     "\
 Return #t if the object is a <gdb:lazy-string> object." },
 
-  { "lazy-string-address", 1, 0, 0, gdbscm_lazy_string_address,
+  { "lazy-string-address", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_lazy_string_address),
     "\
 Return the address of the lazy-string." },
 
-  { "lazy-string-length", 1, 0, 0, gdbscm_lazy_string_length,
+  { "lazy-string-length", 1, 0, 0, as_a_scm_t_subr (gdbscm_lazy_string_length),
     "\
 Return the length of the lazy-string.\n\
 If the length is -1 then the length is determined by the first null\n\
 of appropriate width." },
 
-  { "lazy-string-encoding", 1, 0, 0, gdbscm_lazy_string_encoding,
+  { "lazy-string-encoding", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_lazy_string_encoding),
     "\
 Return the encoding of the lazy-string." },
 
-  { "lazy-string-type", 1, 0, 0, gdbscm_lazy_string_type,
+  { "lazy-string-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_lazy_string_type),
     "\
 Return the <gdb:type> of the lazy-string." },
 
-  { "lazy-string->value", 1, 0, 0, gdbscm_lazy_string_to_value,
+  { "lazy-string->value", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_lazy_string_to_value),
     "\
 Return the <gdb:value> representation of the lazy-string." },
 
diff --git a/gdb/guile/scm-math.c b/gdb/guile/scm-math.c
index 5fbe0eb..a1258bd 100644
--- a/gdb/guile/scm-math.c
+++ b/gdb/guile/scm-math.c
@@ -905,99 +905,99 @@ vlscm_convert_value_from_scheme (const char *func_name,
 
 static const scheme_function math_functions[] =
 {
-  { "value-add", 2, 0, 0, gdbscm_value_add,
+  { "value-add", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_add),
     "\
 Return a + b." },
 
-  { "value-sub", 2, 0, 0, gdbscm_value_sub,
+  { "value-sub", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_sub),
     "\
 Return a - b." },
 
-  { "value-mul", 2, 0, 0, gdbscm_value_mul,
+  { "value-mul", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_mul),
     "\
 Return a * b." },
 
-  { "value-div", 2, 0, 0, gdbscm_value_div,
+  { "value-div", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_div),
     "\
 Return a / b." },
 
-  { "value-rem", 2, 0, 0, gdbscm_value_rem,
+  { "value-rem", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_rem),
     "\
 Return a % b." },
 
-  { "value-mod", 2, 0, 0, gdbscm_value_mod,
+  { "value-mod", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_mod),
     "\
 Return a mod b.  See Knuth 1.2.4." },
 
-  { "value-pow", 2, 0, 0, gdbscm_value_pow,
+  { "value-pow", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_pow),
     "\
 Return pow (x, y)." },
 
-  { "value-not", 1, 0, 0, gdbscm_value_not,
+  { "value-not", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_not),
     "\
 Return !a." },
 
-  { "value-neg", 1, 0, 0, gdbscm_value_neg,
+  { "value-neg", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_neg),
     "\
 Return -a." },
 
-  { "value-pos", 1, 0, 0, gdbscm_value_pos,
+  { "value-pos", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_pos),
     "\
 Return a." },
 
-  { "value-abs", 1, 0, 0, gdbscm_value_abs,
+  { "value-abs", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_abs),
     "\
 Return abs (a)." },
 
-  { "value-lsh", 2, 0, 0, gdbscm_value_lsh,
+  { "value-lsh", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_lsh),
     "\
 Return a << b." },
 
-  { "value-rsh", 2, 0, 0, gdbscm_value_rsh,
+  { "value-rsh", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_rsh),
     "\
 Return a >> b." },
 
-  { "value-min", 2, 0, 0, gdbscm_value_min,
+  { "value-min", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_min),
     "\
 Return min (a, b)." },
 
-  { "value-max", 2, 0, 0, gdbscm_value_max,
+  { "value-max", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_max),
     "\
 Return max (a, b)." },
 
-  { "value-lognot", 1, 0, 0, gdbscm_value_lognot,
+  { "value-lognot", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_lognot),
     "\
 Return ~a." },
 
-  { "value-logand", 2, 0, 0, gdbscm_value_logand,
+  { "value-logand", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_logand),
     "\
 Return a & b." },
 
-  { "value-logior", 2, 0, 0, gdbscm_value_logior,
+  { "value-logior", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_logior),
     "\
 Return a | b." },
 
-  { "value-logxor", 2, 0, 0, gdbscm_value_logxor,
+  { "value-logxor", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_logxor),
     "\
 Return a ^ b." },
 
-  { "value=?", 2, 0, 0, gdbscm_value_eq_p,
+  { "value=?", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_eq_p),
     "\
 Return a == b." },
 
-  { "value<?", 2, 0, 0, gdbscm_value_lt_p,
+  { "value<?", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_lt_p),
     "\
 Return a < b." },
 
-  { "value<=?", 2, 0, 0, gdbscm_value_le_p,
+  { "value<=?", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_le_p),
     "\
 Return a <= b." },
 
-  { "value>?", 2, 0, 0, gdbscm_value_gt_p,
+  { "value>?", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_gt_p),
     "\
 Return a > b." },
 
-  { "value>=?", 2, 0, 0, gdbscm_value_ge_p,
+  { "value>=?", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_ge_p),
     "\
 Return a >= b." },
 
diff --git a/gdb/guile/scm-objfile.c b/gdb/guile/scm-objfile.c
index 080b905..0af151d 100644
--- a/gdb/guile/scm-objfile.c
+++ b/gdb/guile/scm-objfile.c
@@ -389,36 +389,37 @@ gdbscm_objfiles (void)
 
 static const scheme_function objfile_functions[] =
 {
-  { "objfile?", 1, 0, 0, gdbscm_objfile_p,
+  { "objfile?", 1, 0, 0, as_a_scm_t_subr (gdbscm_objfile_p),
     "\
 Return #t if the object is a <gdb:objfile> object." },
 
-  { "objfile-valid?", 1, 0, 0, gdbscm_objfile_valid_p,
+  { "objfile-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_objfile_valid_p),
     "\
 Return #t if the objfile is valid (hasn't been deleted from gdb)." },
 
-  { "objfile-filename", 1, 0, 0, gdbscm_objfile_filename,
+  { "objfile-filename", 1, 0, 0, as_a_scm_t_subr (gdbscm_objfile_filename),
     "\
 Return the file name of the objfile." },
 
-  { "objfile-progspace", 1, 0, 0, gdbscm_objfile_progspace,
+  { "objfile-progspace", 1, 0, 0, as_a_scm_t_subr (gdbscm_objfile_progspace),
     "\
 Return the progspace that the objfile lives in." },
 
-  { "objfile-pretty-printers", 1, 0, 0, gdbscm_objfile_pretty_printers,
+  { "objfile-pretty-printers", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_objfile_pretty_printers),
     "\
 Return a list of pretty-printers of the objfile." },
 
   { "set-objfile-pretty-printers!", 2, 0, 0,
-    gdbscm_set_objfile_pretty_printers_x,
+    as_a_scm_t_subr (gdbscm_set_objfile_pretty_printers_x),
     "\
 Set the list of pretty-printers of the objfile." },
 
-  { "current-objfile", 0, 0, 0, gdbscm_get_current_objfile,
+  { "current-objfile", 0, 0, 0, as_a_scm_t_subr (gdbscm_get_current_objfile),
     "\
 Return the current objfile if there is one or #f if there isn't one." },
 
-  { "objfiles", 0, 0, 0, gdbscm_objfiles,
+  { "objfiles", 0, 0, 0, as_a_scm_t_subr (gdbscm_objfiles),
     "\
 Return a list of all objfiles in the current program space." },
 
diff --git a/gdb/guile/scm-param.c b/gdb/guile/scm-param.c
index 3ddd98f..d216aad 100644
--- a/gdb/guile/scm-param.c
+++ b/gdb/guile/scm-param.c
@@ -1117,7 +1117,7 @@ gdbscm_set_parameter_value_x (SCM self, SCM value)
 
 static const scheme_function parameter_functions[] =
 {
-  { "make-parameter", 1, 0, 1, gdbscm_make_parameter,
+  { "make-parameter", 1, 0, 1, as_a_scm_t_subr (gdbscm_make_parameter),
     "\
 Make a GDB parameter object.\n\
 \n\
@@ -1149,20 +1149,22 @@ Make a GDB parameter object.\n\
     show-doc: The \"doc string\" when showing the parameter.\n\
     initial-value: The initial value of the parameter." },
 
-  { "register-parameter!", 1, 0, 0, gdbscm_register_parameter_x,
+  { "register-parameter!", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_register_parameter_x),
     "\
 Register a <gdb:parameter> object with GDB." },
 
-  { "parameter?", 1, 0, 0, gdbscm_parameter_p,
+  { "parameter?", 1, 0, 0, as_a_scm_t_subr (gdbscm_parameter_p),
     "\
 Return #t if the object is a <gdb:parameter> object." },
 
-  { "parameter-value", 1, 0, 0, gdbscm_parameter_value,
+  { "parameter-value", 1, 0, 0, as_a_scm_t_subr (gdbscm_parameter_value),
     "\
 Return the value of a <gdb:parameter> object\n\
 or any gdb parameter if param is a string naming the parameter." },
 
-  { "set-parameter-value!", 2, 0, 0, gdbscm_set_parameter_value_x,
+  { "set-parameter-value!", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_set_parameter_value_x),
     "\
 Set the value of a <gdb:parameter> object.\n\
 \n\
diff --git a/gdb/guile/scm-ports.c b/gdb/guile/scm-ports.c
index 622507b..e406ae1 100644
--- a/gdb/guile/scm-ports.c
+++ b/gdb/guile/scm-ports.c
@@ -1287,44 +1287,44 @@ gdbscm_set_memory_port_write_buffer_size_x (SCM port, SCM size)
 
 static const scheme_function port_functions[] =
 {
-  { "input-port", 0, 0, 0, gdbscm_input_port,
+  { "input-port", 0, 0, 0, as_a_scm_t_subr (gdbscm_input_port),
     "\
 Return gdb's input port." },
 
-  { "output-port", 0, 0, 0, gdbscm_output_port,
+  { "output-port", 0, 0, 0, as_a_scm_t_subr (gdbscm_output_port),
     "\
 Return gdb's output port." },
 
-  { "error-port", 0, 0, 0, gdbscm_error_port,
+  { "error-port", 0, 0, 0, as_a_scm_t_subr (gdbscm_error_port),
     "\
 Return gdb's error port." },
 
-  { "stdio-port?", 1, 0, 0, gdbscm_stdio_port_p,
+  { "stdio-port?", 1, 0, 0, as_a_scm_t_subr (gdbscm_stdio_port_p),
     "\
 Return #t if the object is a gdb:stdio-port." },
 
-  { "open-memory", 0, 0, 1, gdbscm_open_memory,
+  { "open-memory", 0, 0, 1, as_a_scm_t_subr (gdbscm_open_memory),
     "\
 Return a port that can be used for reading/writing inferior memory.\n\
 \n\
   Arguments: [#:mode string] [#:start address] [#:size integer]\n\
   Returns: A port object." },
 
-  { "memory-port?", 1, 0, 0, gdbscm_memory_port_p,
+  { "memory-port?", 1, 0, 0, as_a_scm_t_subr (gdbscm_memory_port_p),
     "\
 Return #t if the object is a memory port." },
 
-  { "memory-port-range", 1, 0, 0, gdbscm_memory_port_range,
+  { "memory-port-range", 1, 0, 0, as_a_scm_t_subr (gdbscm_memory_port_range),
     "\
 Return the memory range of the port as (start end)." },
 
   { "memory-port-read-buffer-size", 1, 0, 0,
-    gdbscm_memory_port_read_buffer_size,
+    as_a_scm_t_subr (gdbscm_memory_port_read_buffer_size),
     "\
 Return the size of the read buffer for the memory port." },
 
   { "set-memory-port-read-buffer-size!", 2, 0, 0,
-    gdbscm_set_memory_port_read_buffer_size_x,
+    as_a_scm_t_subr (gdbscm_set_memory_port_read_buffer_size_x),
     "\
 Set the size of the read buffer for the memory port.\n\
 \n\
@@ -1332,12 +1332,12 @@ Set the size of the read buffer for the memory port.\n\
   Returns: unspecified." },
 
   { "memory-port-write-buffer-size", 1, 0, 0,
-    gdbscm_memory_port_write_buffer_size,
+    as_a_scm_t_subr (gdbscm_memory_port_write_buffer_size),
     "\
 Return the size of the write buffer for the memory port." },
 
   { "set-memory-port-write-buffer-size!", 2, 0, 0,
-    gdbscm_set_memory_port_write_buffer_size_x,
+    as_a_scm_t_subr (gdbscm_set_memory_port_write_buffer_size_x),
     "\
 Set the size of the write buffer for the memory port.\n\
 \n\
@@ -1351,7 +1351,7 @@ static const scheme_function private_port_functions[] =
 {
 #if 0 /* TODO */
   { "%with-gdb-input-from-port", 2, 0, 0,
-    gdbscm_percent_with_gdb_input_from_port,
+    as_a_scm_t_subr (gdbscm_percent_with_gdb_input_from_port),
     "\
 Temporarily set GDB's input port to PORT and then invoke THUNK.\n\
 \n\
@@ -1362,7 +1362,7 @@ This procedure is experimental." },
 #endif
 
   { "%with-gdb-output-to-port", 2, 0, 0,
-    gdbscm_percent_with_gdb_output_to_port,
+    as_a_scm_t_subr (gdbscm_percent_with_gdb_output_to_port),
     "\
 Temporarily set GDB's output port to PORT and then invoke THUNK.\n\
 \n\
@@ -1372,7 +1372,7 @@ Temporarily set GDB's output port to PORT and then invoke THUNK.\n\
 This procedure is experimental." },
 
   { "%with-gdb-error-to-port", 2, 0, 0,
-    gdbscm_percent_with_gdb_error_to_port,
+    as_a_scm_t_subr (gdbscm_percent_with_gdb_error_to_port),
     "\
 Temporarily set GDB's error port to PORT and then invoke THUNK.\n\
 \n\
diff --git a/gdb/guile/scm-pretty-print.c b/gdb/guile/scm-pretty-print.c
index 879c4ea..a288a64 100644
--- a/gdb/guile/scm-pretty-print.c
+++ b/gdb/guile/scm-pretty-print.c
@@ -1055,7 +1055,8 @@ gdbscm_apply_val_pretty_printer (const struct extension_language_defn *extlang,
 
 static const scheme_function pretty_printer_functions[] =
 {
-  { "make-pretty-printer", 2, 0, 0, gdbscm_make_pretty_printer,
+  { "make-pretty-printer", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_make_pretty_printer),
     "\
 Create a <gdb:pretty-printer> object.\n\
 \n\
@@ -1064,21 +1065,23 @@ Create a <gdb:pretty-printer> object.\n\
     lookup: a procedure:\n\
       (pretty-printer <gdb:value>) -> <gdb:pretty-printer-worker> | #f." },
 
-  { "pretty-printer?", 1, 0, 0, gdbscm_pretty_printer_p,
+  { "pretty-printer?", 1, 0, 0, as_a_scm_t_subr (gdbscm_pretty_printer_p),
     "\
 Return #t if the object is a <gdb:pretty-printer> object." },
 
-  { "pretty-printer-enabled?", 1, 0, 0, gdbscm_pretty_printer_enabled_p,
+  { "pretty-printer-enabled?", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_pretty_printer_enabled_p),
     "\
 Return #t if the pretty-printer is enabled." },
 
   { "set-pretty-printer-enabled!", 2, 0, 0,
-    gdbscm_set_pretty_printer_enabled_x,
+    as_a_scm_t_subr (gdbscm_set_pretty_printer_enabled_x),
     "\
 Set the enabled flag of the pretty-printer.\n\
 Returns \"unspecified\"." },
 
-  { "make-pretty-printer-worker", 3, 0, 0, gdbscm_make_pretty_printer_worker,
+  { "make-pretty-printer-worker", 3, 0, 0,
+    as_a_scm_t_subr (gdbscm_make_pretty_printer_worker),
     "\
 Create a <gdb:pretty-printer-worker> object.\n\
 \n\
@@ -1089,16 +1092,17 @@ Create a <gdb:pretty-printer-worker> object.\n\
     children:     either #f or a procedure:\n\
       (pretty-printer) -> <gdb:iterator>" },
 
-  { "pretty-printer-worker?", 1, 0, 0, gdbscm_pretty_printer_worker_p,
+  { "pretty-printer-worker?", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_pretty_printer_worker_p),
     "\
 Return #t if the object is a <gdb:pretty-printer-worker> object." },
 
-  { "pretty-printers", 0, 0, 0, gdbscm_pretty_printers,
+  { "pretty-printers", 0, 0, 0, as_a_scm_t_subr (gdbscm_pretty_printers),
     "\
 Return the list of global pretty-printers." },
 
   { "set-pretty-printers!", 1, 0, 0,
-    gdbscm_set_pretty_printers_x,
+    as_a_scm_t_subr (gdbscm_set_pretty_printers_x),
     "\
 Set the list of global pretty-printers." },
 
diff --git a/gdb/guile/scm-progspace.c b/gdb/guile/scm-progspace.c
index ec68d22..a95e834 100644
--- a/gdb/guile/scm-progspace.c
+++ b/gdb/guile/scm-progspace.c
@@ -373,38 +373,39 @@ gdbscm_progspaces (void)
 
 static const scheme_function pspace_functions[] =
 {
-  { "progspace?", 1, 0, 0, gdbscm_progspace_p,
+  { "progspace?", 1, 0, 0, as_a_scm_t_subr (gdbscm_progspace_p),
     "\
 Return #t if the object is a <gdb:objfile> object." },
 
-  { "progspace-valid?", 1, 0, 0, gdbscm_progspace_valid_p,
+  { "progspace-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_progspace_valid_p),
     "\
 Return #t if the progspace is valid (hasn't been deleted from gdb)." },
 
-  { "progspace-filename", 1, 0, 0, gdbscm_progspace_filename,
+  { "progspace-filename", 1, 0, 0, as_a_scm_t_subr (gdbscm_progspace_filename),
     "\
 Return the name of the main symbol file of the progspace." },
 
-  { "progspace-objfiles", 1, 0, 0, gdbscm_progspace_objfiles,
+  { "progspace-objfiles", 1, 0, 0, as_a_scm_t_subr (gdbscm_progspace_objfiles),
     "\
 Return the list of objfiles associated with the progspace.\n\
 Objfiles that are separate debug objfiles are not included in the result.\n\
 The order of appearance of objfiles in the result is arbitrary." },
 
-  { "progspace-pretty-printers", 1, 0, 0, gdbscm_progspace_pretty_printers,
+  { "progspace-pretty-printers", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_progspace_pretty_printers),
     "\
 Return a list of pretty-printers of the progspace." },
 
   { "set-progspace-pretty-printers!", 2, 0, 0,
-    gdbscm_set_progspace_pretty_printers_x,
+    as_a_scm_t_subr (gdbscm_set_progspace_pretty_printers_x),
     "\
 Set the list of pretty-printers of the progspace." },
 
-  { "current-progspace", 0, 0, 0, gdbscm_current_progspace,
+  { "current-progspace", 0, 0, 0, as_a_scm_t_subr (gdbscm_current_progspace),
     "\
 Return the current program space if there is one or #f if there isn't one." },
 
-  { "progspaces", 0, 0, 0, gdbscm_progspaces,
+  { "progspaces", 0, 0, 0, as_a_scm_t_subr (gdbscm_progspaces),
     "\
 Return a list of all program spaces." },
 
diff --git a/gdb/guile/scm-string.c b/gdb/guile/scm-string.c
index 587ad75..c55da90 100644
--- a/gdb/guile/scm-string.c
+++ b/gdb/guile/scm-string.c
@@ -268,7 +268,7 @@ gdbscm_string_to_argv (SCM string_scm)
 
 static const scheme_function string_functions[] =
 {
-  { "string->argv", 1, 0, 0, gdbscm_string_to_argv,
+  { "string->argv", 1, 0, 0, as_a_scm_t_subr (gdbscm_string_to_argv),
   "\
 Convert a string to a list of strings split up according to\n\
 gdb's argv parsing rules." },
diff --git a/gdb/guile/scm-symbol.c b/gdb/guile/scm-symbol.c
index 0970a72..f711a02 100644
--- a/gdb/guile/scm-symbol.c
+++ b/gdb/guile/scm-symbol.c
@@ -716,73 +716,75 @@ static const scheme_integer_constant symbol_integer_constants[] =
 
 static const scheme_function symbol_functions[] =
 {
-  { "symbol?", 1, 0, 0, gdbscm_symbol_p,
+  { "symbol?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_p),
     "\
 Return #t if the object is a <gdb:symbol> object." },
 
-  { "symbol-valid?", 1, 0, 0, gdbscm_symbol_valid_p,
+  { "symbol-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_valid_p),
     "\
 Return #t if object is a valid <gdb:symbol> object.\n\
 A valid symbol is a symbol that has not been freed.\n\
 Symbols are freed when the objfile they come from is freed." },
 
-  { "symbol-type", 1, 0, 0, gdbscm_symbol_type,
+  { "symbol-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_type),
     "\
 Return the type of symbol." },
 
-  { "symbol-symtab", 1, 0, 0, gdbscm_symbol_symtab,
+  { "symbol-symtab", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_symtab),
     "\
 Return the symbol table (<gdb:symtab>) containing symbol." },
 
-  { "symbol-line", 1, 0, 0, gdbscm_symbol_line,
+  { "symbol-line", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_line),
     "\
 Return the line number at which the symbol was defined." },
 
-  { "symbol-name", 1, 0, 0, gdbscm_symbol_name,
+  { "symbol-name", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_name),
     "\
 Return the name of the symbol as a string." },
 
-  { "symbol-linkage-name", 1, 0, 0, gdbscm_symbol_linkage_name,
+  { "symbol-linkage-name", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_symbol_linkage_name),
     "\
 Return the linkage name of the symbol as a string." },
 
-  { "symbol-print-name", 1, 0, 0, gdbscm_symbol_print_name,
+  { "symbol-print-name", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_print_name),
     "\
 Return the print name of the symbol as a string.\n\
 This is either name or linkage-name, depending on whether the user\n\
 asked GDB to display demangled or mangled names." },
 
-  { "symbol-addr-class", 1, 0, 0, gdbscm_symbol_addr_class,
+  { "symbol-addr-class", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_addr_class),
     "\
 Return the address class of the symbol." },
 
-  { "symbol-needs-frame?", 1, 0, 0, gdbscm_symbol_needs_frame_p,
+  { "symbol-needs-frame?", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_symbol_needs_frame_p),
     "\
 Return #t if the symbol needs a frame to compute its value." },
 
-  { "symbol-argument?", 1, 0, 0, gdbscm_symbol_argument_p,
+  { "symbol-argument?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_argument_p),
     "\
 Return #t if the symbol is a function argument." },
 
-  { "symbol-constant?", 1, 0, 0, gdbscm_symbol_constant_p,
+  { "symbol-constant?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_constant_p),
     "\
 Return #t if the symbol is a constant." },
 
-  { "symbol-function?", 1, 0, 0, gdbscm_symbol_function_p,
+  { "symbol-function?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_function_p),
     "\
 Return #t if the symbol is a function." },
 
-  { "symbol-variable?", 1, 0, 0, gdbscm_symbol_variable_p,
+  { "symbol-variable?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symbol_variable_p),
     "\
 Return #t if the symbol is a variable." },
 
-  { "symbol-value", 1, 0, 1, gdbscm_symbol_value,
+  { "symbol-value", 1, 0, 1, as_a_scm_t_subr (gdbscm_symbol_value),
     "\
 Return the value of the symbol.\n\
 \n\
   Arguments: <gdb:symbol> [#:frame frame]" },
 
-  { "lookup-symbol", 1, 0, 1, gdbscm_lookup_symbol,
+  { "lookup-symbol", 1, 0, 1, as_a_scm_t_subr (gdbscm_lookup_symbol),
     "\
 Return (<gdb:symbol> field-of-this?) if found, otherwise #f.\n\
 \n\
@@ -791,7 +793,8 @@ Return (<gdb:symbol> field-of-this?) if found, otherwise #f.\n\
     block:  a <gdb:block> object\n\
     domain: a SYMBOL_*_DOMAIN value" },
 
-  { "lookup-global-symbol", 1, 0, 1, gdbscm_lookup_global_symbol,
+  { "lookup-global-symbol", 1, 0, 1,
+    as_a_scm_t_subr (gdbscm_lookup_global_symbol),
     "\
 Return <gdb:symbol> if found, otherwise #f.\n\
 \n\
diff --git a/gdb/guile/scm-symtab.c b/gdb/guile/scm-symtab.c
index 009a2b4..6d16b27 100644
--- a/gdb/guile/scm-symtab.c
+++ b/gdb/guile/scm-symtab.c
@@ -614,61 +614,63 @@ gdbscm_find_pc_line (SCM pc_scm)
 
 static const scheme_function symtab_functions[] =
 {
-  { "symtab?", 1, 0, 0, gdbscm_symtab_p,
+  { "symtab?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_p),
     "\
 Return #t if the object is a <gdb:symtab> object." },
 
-  { "symtab-valid?", 1, 0, 0, gdbscm_symtab_valid_p,
+  { "symtab-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_valid_p),
     "\
 Return #t if the symtab still exists in GDB.\n\
 Symtabs are deleted when the corresponding objfile is freed." },
 
-  { "symtab-filename", 1, 0, 0, gdbscm_symtab_filename,
+  { "symtab-filename", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_filename),
     "\
 Return the symtab's source file name." },
 
-  { "symtab-fullname", 1, 0, 0, gdbscm_symtab_fullname,
+  { "symtab-fullname", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_fullname),
     "\
 Return the symtab's full source file name." },
 
-  { "symtab-objfile", 1, 0, 0, gdbscm_symtab_objfile,
+  { "symtab-objfile", 1, 0, 0, as_a_scm_t_subr (gdbscm_symtab_objfile),
     "\
 Return the symtab's objfile." },
 
-  { "symtab-global-block", 1, 0, 0, gdbscm_symtab_global_block,
+  { "symtab-global-block", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_symtab_global_block),
     "\
 Return the symtab's global block." },
 
-  { "symtab-static-block", 1, 0, 0, gdbscm_symtab_static_block,
+  { "symtab-static-block", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_symtab_static_block),
     "\
 Return the symtab's static block." },
 
-  { "sal?", 1, 0, 0, gdbscm_sal_p,
+  { "sal?", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_p),
     "\
 Return #t if the object is a <gdb:sal> (symtab-and-line) object." },
 
-  { "sal-valid?", 1, 0, 0, gdbscm_sal_valid_p,
+  { "sal-valid?", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_valid_p),
     "\
 Return #t if the symtab for the sal still exists in GDB.\n\
 Symtabs are deleted when the corresponding objfile is freed." },
 
-  { "sal-symtab", 1, 0, 0, gdbscm_sal_symtab,
+  { "sal-symtab", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_symtab),
     "\
 Return the sal's symtab." },
 
-  { "sal-line", 1, 0, 0, gdbscm_sal_line,
+  { "sal-line", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_line),
     "\
 Return the sal's line number, or #f if there is none." },
 
-  { "sal-pc", 1, 0, 0, gdbscm_sal_pc,
+  { "sal-pc", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_pc),
     "\
 Return the sal's address." },
 
-  { "sal-last", 1, 0, 0, gdbscm_sal_last,
+  { "sal-last", 1, 0, 0, as_a_scm_t_subr (gdbscm_sal_last),
     "\
 Return the last address specified by the sal, or #f if there is none." },
 
-  { "find-pc-line", 1, 0, 0, gdbscm_find_pc_line,
+  { "find-pc-line", 1, 0, 0, as_a_scm_t_subr (gdbscm_find_pc_line),
     "\
 Return the sal corresponding to the address, or #f if there isn't one.\n\
 \n\
diff --git a/gdb/guile/scm-type.c b/gdb/guile/scm-type.c
index fa0c213..11b355d 100644
--- a/gdb/guile/scm-type.c
+++ b/gdb/guile/scm-type.c
@@ -1341,42 +1341,43 @@ static const scheme_integer_constant type_integer_constants[] =
 
 static const scheme_function type_functions[] =
 {
-  { "type?", 1, 0, 0, gdbscm_type_p,
+  { "type?", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_p),
     "\
 Return #t if the object is a <gdb:type> object." },
 
-  { "lookup-type", 1, 0, 1, gdbscm_lookup_type,
+  { "lookup-type", 1, 0, 1, as_a_scm_t_subr (gdbscm_lookup_type),
     "\
 Return the <gdb:type> object representing string or #f if not found.\n\
 If block is given then the type is looked for in that block.\n\
 \n\
   Arguments: string [#:block <gdb:block>]" },
 
-  { "type-code", 1, 0, 0, gdbscm_type_code,
+  { "type-code", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_code),
     "\
 Return the code of the type" },
 
-  { "type-tag", 1, 0, 0, gdbscm_type_tag,
+  { "type-tag", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_tag),
     "\
 Return the tag name of the type, or #f if there isn't one." },
 
-  { "type-name", 1, 0, 0, gdbscm_type_name,
+  { "type-name", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_name),
     "\
 Return the name of the type as a string, or #f if there isn't one." },
 
-  { "type-print-name", 1, 0, 0, gdbscm_type_print_name,
+  { "type-print-name", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_print_name),
     "\
 Return the print name of the type as a string." },
 
-  { "type-sizeof", 1, 0, 0, gdbscm_type_sizeof,
+  { "type-sizeof", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_sizeof),
     "\
 Return the size of the type, in bytes." },
 
-  { "type-strip-typedefs", 1, 0, 0, gdbscm_type_strip_typedefs,
+  { "type-strip-typedefs", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_type_strip_typedefs),
     "\
 Return a type formed by stripping the type of all typedefs." },
 
-  { "type-array", 2, 1, 0, gdbscm_type_array,
+  { "type-array", 2, 1, 0, as_a_scm_t_subr (gdbscm_type_array),
     "\
 Return a type representing an array of objects of the type.\n\
 \n\
@@ -1386,7 +1387,7 @@ Return a type representing an array of objects of the type.\n\
     the array size.\n\
     Valid bounds for array indices are [low-bound,high-bound]." },
 
-  { "type-vector", 2, 1, 0, gdbscm_type_vector,
+  { "type-vector", 2, 1, 0, as_a_scm_t_subr (gdbscm_type_vector),
     "\
 Return a type representing a vector of objects of the type.\n\
 Vectors differ from arrays in that if the current language has C-style\n\
@@ -1399,87 +1400,88 @@ They are first class values.\n\
     the array size.\n\
     Valid bounds for array indices are [low-bound,high-bound]." },
 
-  { "type-pointer", 1, 0, 0, gdbscm_type_pointer,
+  { "type-pointer", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_pointer),
     "\
 Return a type of pointer to the type." },
 
-  { "type-range", 1, 0, 0, gdbscm_type_range,
+  { "type-range", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_range),
     "\
 Return (low high) representing the range for the type." },
 
-  { "type-reference", 1, 0, 0, gdbscm_type_reference,
+  { "type-reference", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_reference),
     "\
 Return a type of reference to the type." },
 
-  { "type-target", 1, 0, 0, gdbscm_type_target,
+  { "type-target", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_target),
     "\
 Return the target type of the type." },
 
-  { "type-const", 1, 0, 0, gdbscm_type_const,
+  { "type-const", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_const),
     "\
 Return a const variant of the type." },
 
-  { "type-volatile", 1, 0, 0, gdbscm_type_volatile,
+  { "type-volatile", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_volatile),
     "\
 Return a volatile variant of the type." },
 
-  { "type-unqualified", 1, 0, 0, gdbscm_type_unqualified,
+  { "type-unqualified", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_unqualified),
     "\
 Return a variant of the type without const or volatile attributes." },
 
-  { "type-num-fields", 1, 0, 0, gdbscm_type_num_fields,
+  { "type-num-fields", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_num_fields),
     "\
 Return the number of fields of the type." },
 
-  { "type-fields", 1, 0, 0, gdbscm_type_fields,
+  { "type-fields", 1, 0, 0, as_a_scm_t_subr (gdbscm_type_fields),
     "\
 Return the list of <gdb:field> objects of fields of the type." },
 
-  { "make-field-iterator", 1, 0, 0, gdbscm_make_field_iterator,
+  { "make-field-iterator", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_make_field_iterator),
     "\
 Return a <gdb:iterator> object for iterating over the fields of the type." },
 
-  { "type-field", 2, 0, 0, gdbscm_type_field,
+  { "type-field", 2, 0, 0, as_a_scm_t_subr (gdbscm_type_field),
     "\
 Return the field named by string of the type.\n\
 \n\
   Arguments: <gdb:type> string" },
 
-  { "type-has-field?", 2, 0, 0, gdbscm_type_has_field_p,
+  { "type-has-field?", 2, 0, 0, as_a_scm_t_subr (gdbscm_type_has_field_p),
     "\
 Return #t if the type has field named string.\n\
 \n\
   Arguments: <gdb:type> string" },
 
-  { "field?", 1, 0, 0, gdbscm_field_p,
+  { "field?", 1, 0, 0, as_a_scm_t_subr (gdbscm_field_p),
     "\
 Return #t if the object is a <gdb:field> object." },
 
-  { "field-name", 1, 0, 0, gdbscm_field_name,
+  { "field-name", 1, 0, 0, as_a_scm_t_subr (gdbscm_field_name),
     "\
 Return the name of the field." },
 
-  { "field-type", 1, 0, 0, gdbscm_field_type,
+  { "field-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_field_type),
     "\
 Return the type of the field." },
 
-  { "field-enumval", 1, 0, 0, gdbscm_field_enumval,
+  { "field-enumval", 1, 0, 0, as_a_scm_t_subr (gdbscm_field_enumval),
     "\
 Return the enum value represented by the field." },
 
-  { "field-bitpos", 1, 0, 0, gdbscm_field_bitpos,
+  { "field-bitpos", 1, 0, 0, as_a_scm_t_subr (gdbscm_field_bitpos),
     "\
 Return the offset in bits of the field in its containing type." },
 
-  { "field-bitsize", 1, 0, 0, gdbscm_field_bitsize,
+  { "field-bitsize", 1, 0, 0, as_a_scm_t_subr (gdbscm_field_bitsize),
     "\
 Return the size of the field in bits." },
 
-  { "field-artificial?", 1, 0, 0, gdbscm_field_artificial_p,
+  { "field-artificial?", 1, 0, 0, as_a_scm_t_subr (gdbscm_field_artificial_p),
     "\
 Return #t if the field is artificial." },
 
-  { "field-baseclass?", 1, 0, 0, gdbscm_field_baseclass_p,
+  { "field-baseclass?", 1, 0, 0, as_a_scm_t_subr (gdbscm_field_baseclass_p),
     "\
 Return #t if the field is a baseclass." },
 
@@ -1504,7 +1506,7 @@ gdbscm_initialize_types (void)
   /* This function is "private".  */
   tyscm_next_field_x_proc
     = scm_c_define_gsubr ("%type-next-field!", 1, 0, 0,
-			  gdbscm_type_next_field_x);
+			  as_a_scm_t_subr (gdbscm_type_next_field_x));
   scm_set_procedure_property_x (tyscm_next_field_x_proc,
 				gdbscm_documentation_symbol,
 				gdbscm_scm_from_c_string ("\
diff --git a/gdb/guile/scm-value.c b/gdb/guile/scm-value.c
index 25c2957..f25f7d5 100644
--- a/gdb/guile/scm-value.c
+++ b/gdb/guile/scm-value.c
@@ -1410,11 +1410,11 @@ gdbscm_history_append_x (SCM value)
 
 static const scheme_function value_functions[] =
 {
-  { "value?", 1, 0, 0, gdbscm_value_p,
+  { "value?", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_p),
     "\
 Return #t if the object is a <gdb:value> object." },
 
-  { "make-value", 1, 0, 1, gdbscm_make_value,
+  { "make-value", 1, 0, 1, as_a_scm_t_subr (gdbscm_make_value),
     "\
 Create a <gdb:value> representing object.\n\
 Typically this is used to convert numbers and strings to\n\
@@ -1422,47 +1422,50 @@ Typically this is used to convert numbers and strings to\n\
 \n\
   Arguments: object [#:type <gdb:type>]" },
 
-  { "value-optimized-out?", 1, 0, 0, gdbscm_value_optimized_out_p,
+  { "value-optimized-out?", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_value_optimized_out_p),
     "\
 Return #t if the value has been optimizd out." },
 
-  { "value-address", 1, 0, 0, gdbscm_value_address,
+  { "value-address", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_address),
     "\
 Return the address of the value." },
 
-  { "value-type", 1, 0, 0, gdbscm_value_type,
+  { "value-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_type),
     "\
 Return the type of the value." },
 
-  { "value-dynamic-type", 1, 0, 0, gdbscm_value_dynamic_type,
+  { "value-dynamic-type", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_dynamic_type),
     "\
 Return the dynamic type of the value." },
 
-  { "value-cast", 2, 0, 0, gdbscm_value_cast,
+  { "value-cast", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_cast),
     "\
 Cast the value to the supplied type.\n\
 \n\
   Arguments: <gdb:value> <gdb:type>" },
 
-  { "value-dynamic-cast", 2, 0, 0, gdbscm_value_dynamic_cast,
+  { "value-dynamic-cast", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_dynamic_cast),
     "\
 Cast the value to the supplied type, as if by the C++\n\
 dynamic_cast operator.\n\
 \n\
   Arguments: <gdb:value> <gdb:type>" },
 
-  { "value-reinterpret-cast", 2, 0, 0, gdbscm_value_reinterpret_cast,
+  { "value-reinterpret-cast", 2, 0, 0,
+    as_a_scm_t_subr (gdbscm_value_reinterpret_cast),
     "\
 Cast the value to the supplied type, as if by the C++\n\
 reinterpret_cast operator.\n\
 \n\
   Arguments: <gdb:value> <gdb:type>" },
 
-  { "value-dereference", 1, 0, 0, gdbscm_value_dereference,
+  { "value-dereference", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_dereference),
     "\
 Return the result of applying the C unary * operator to the value." },
 
-  { "value-referenced-value", 1, 0, 0, gdbscm_value_referenced_value,
+  { "value-referenced-value", 1, 0, 0,
+    as_a_scm_t_subr (gdbscm_value_referenced_value),
     "\
 Given a value of a reference type, return the value referenced.\n\
 The difference between this function and value-dereference is that\n\
@@ -1472,19 +1475,19 @@ For example, for a value which is a reference to an 'int' pointer ('int *'),\n\
 value-dereference will result in a value of type 'int' while\n\
 value-referenced-value will result in a value of type 'int *'." },
 
-  { "value-field", 2, 0, 0, gdbscm_value_field,
+  { "value-field", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_field),
     "\
 Return the specified field of the value.\n\
 \n\
   Arguments: <gdb:value> string" },
 
-  { "value-subscript", 2, 0, 0, gdbscm_value_subscript,
+  { "value-subscript", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_subscript),
     "\
 Return the value of the array at the specified index.\n\
 \n\
   Arguments: <gdb:value> integer" },
 
-  { "value-call", 2, 0, 0, gdbscm_value_call,
+  { "value-call", 2, 0, 0, as_a_scm_t_subr (gdbscm_value_call),
     "\
 Perform an inferior function call taking the value as a pointer to the\n\
 function to call.\n\
@@ -1494,27 +1497,27 @@ The result is the value returned by the function.\n\
 \n\
   Arguments: <gdb:value> arg-list" },
 
-  { "value->bool", 1, 0, 0, gdbscm_value_to_bool,
+  { "value->bool", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_to_bool),
     "\
 Return the Scheme boolean representing the GDB value.\n\
 The value must be \"integer like\".  Pointers are ok." },
 
-  { "value->integer", 1, 0, 0, gdbscm_value_to_integer,
+  { "value->integer", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_to_integer),
     "\
 Return the Scheme integer representing the GDB value.\n\
 The value must be \"integer like\".  Pointers are ok." },
 
-  { "value->real", 1, 0, 0, gdbscm_value_to_real,
+  { "value->real", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_to_real),
     "\
 Return the Scheme real number representing the GDB value.\n\
 The value must be a number." },
 
-  { "value->bytevector", 1, 0, 0, gdbscm_value_to_bytevector,
+  { "value->bytevector", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_to_bytevector),
     "\
 Return a Scheme bytevector with the raw contents of the GDB value.\n\
 No transformation, endian or otherwise, is performed." },
 
-  { "value->string", 1, 0, 1, gdbscm_value_to_string,
+  { "value->string", 1, 0, 1, as_a_scm_t_subr (gdbscm_value_to_string),
     "\
 Return the Unicode string of the value's contents.\n\
 If ENCODING is not given, the string is assumed to be encoded in\n\
@@ -1528,7 +1531,8 @@ If LENGTH is provided, only fetch string to the length provided.\n\
              [#:encoding encoding] [#:errors \"error\"|\"substitute\"]\n\
              [#:length length]" },
 
-  { "value->lazy-string", 1, 0, 1, gdbscm_value_to_lazy_string,
+  { "value->lazy-string", 1, 0, 1,
+    as_a_scm_t_subr (gdbscm_value_to_lazy_string),
     "\
 Return a Scheme object representing a lazily fetched Unicode string\n\
 of the value's contents.\n\
@@ -1538,36 +1542,36 @@ If LENGTH is provided, only fetch string to the length provided.\n\
 \n\
   Arguments: <gdb:value> [#:encoding encoding] [#:length length]" },
 
-  { "value-lazy?", 1, 0, 0, gdbscm_value_lazy_p,
+  { "value-lazy?", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_lazy_p),
     "\
 Return #t if the value is lazy (not fetched yet from the inferior).\n\
 A lazy value is fetched when needed, or when the value-fetch-lazy! function\n\
 is called." },
 
-  { "make-lazy-value", 2, 0, 0, gdbscm_make_lazy_value,
+  { "make-lazy-value", 2, 0, 0, as_a_scm_t_subr (gdbscm_make_lazy_value),
     "\
 Create a <gdb:value> that will be lazily fetched from the target.\n\
 \n\
   Arguments: <gdb:type> address" },
 
-  { "value-fetch-lazy!", 1, 0, 0, gdbscm_value_fetch_lazy_x,
+  { "value-fetch-lazy!", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_fetch_lazy_x),
     "\
 Fetch the value from the inferior, if it was lazy.\n\
 The result is \"unspecified\"." },
 
-  { "value-print", 1, 0, 0, gdbscm_value_print,
+  { "value-print", 1, 0, 0, as_a_scm_t_subr (gdbscm_value_print),
     "\
 Return the string representation (print form) of the value." },
 
-  { "parse-and-eval", 1, 0, 0, gdbscm_parse_and_eval,
+  { "parse-and-eval", 1, 0, 0, as_a_scm_t_subr (gdbscm_parse_and_eval),
     "\
 Evaluates string in gdb and returns the result as a <gdb:value> object." },
 
-  { "history-ref", 1, 0, 0, gdbscm_history_ref,
+  { "history-ref", 1, 0, 0, as_a_scm_t_subr (gdbscm_history_ref),
     "\
 Return the specified value from GDB's value history." },
 
-  { "history-append!", 1, 0, 0, gdbscm_history_append_x,
+  { "history-append!", 1, 0, 0, as_a_scm_t_subr (gdbscm_history_append_x),
     "\
 Append the specified value onto GDB's value history." },
 
