}
#endif
-void _initialize_aarch64_fbsd_nat ();
-void
-_initialize_aarch64_fbsd_nat ()
+INIT_GDB_FILE (aarch64_fbsd_nat)
{
#ifdef HAVE_DBREG
aarch64_initialize_hw_point ();
}
}
-void _initialize_aarch64_fbsd_tdep ();
-void
-_initialize_aarch64_fbsd_tdep ()
+INIT_GDB_FILE (aarch64_fbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_aarch64, 0, GDB_OSABI_FREEBSD,
aarch64_fbsd_init_abi);
return gdbarch_tagged_address_p (gdbarch, address);
}
-void _initialize_aarch64_linux_nat ();
-void
-_initialize_aarch64_linux_nat ()
+INIT_GDB_FILE (aarch64_linux_nat)
{
aarch64_initialize_hw_point ();
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
-void _initialize_aarch64_linux_tdep ();
-void
-_initialize_aarch64_linux_tdep ()
+INIT_GDB_FILE (aarch64_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_aarch64, 0, GDB_OSABI_LINUX,
aarch64_linux_init_abi);
tdep->jb_pc = 11;
}
-void _initialize_aarch64_newlib_tdep ();
-void
-_initialize_aarch64_newlib_tdep ()
+INIT_GDB_FILE (aarch64_newlib_tdep)
{
gdbarch_register_osabi (bfd_arch_aarch64, 0, GDB_OSABI_NEWLIB,
aarch64_newlib_init_abi);
}
#endif
-void _initialize_aarch64_tdep ();
-void
-_initialize_aarch64_tdep ()
+INIT_GDB_FILE (aarch64_tdep)
{
gdbarch_register (bfd_arch_aarch64, aarch64_gdbarch_init,
aarch64_dump_tdep);
nullptr
};
-void _initialize_ada_language ();
-void
-_initialize_ada_language ()
+INIT_GDB_FILE (ada_language)
{
add_setshow_prefix_cmd
("ada", no_class,
from_tty, flags);
}
-void _initialize_tasks ();
-void
-_initialize_tasks ()
+INIT_GDB_FILE (tasks)
{
/* Attach various observers. */
gdb::observers::normal_stop.attach (ada_tasks_normal_stop_observer,
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
-void _initialize_addrmap ();
-void
-_initialize_addrmap ()
+INIT_GDB_FILE (addrmap)
{
#if GDB_SELF_TEST
selftests::register_test ("addrmap", selftests::test_addrmap);
agent_look_up_symbols (objfile);
}
-void _initialize_agent ();
-void
-_initialize_agent ()
+INIT_GDB_FILE (agent)
{
gdb::observers::new_objfile.attach (agent_new_objfile,
"agent");
/* Module startup initialization function, automagically called by
init.c. */
-void _initialize_aix_thread ();
-void
-_initialize_aix_thread ()
+INIT_GDB_FILE (aix_thread)
{
/* Notice when object files get loaded and unloaded. */
gdb::observers::new_objfile.attach (new_objfile, "aix-thread");
}
\f
-void _initialize_alphabsd_nat ();
-void
-_initialize_alphabsd_nat ()
+INIT_GDB_FILE (alphabsd_nat)
{
add_inf_child_target (&the_alpha_bsd_nat_target);
return FPR_BASE + regno - gdbarch_fp0_regnum (gdbarch);
}
-void _initialize_alpha_linux_nat ();
-void
-_initialize_alpha_linux_nat ()
+INIT_GDB_FILE (alpha_linux_nat)
{
linux_target = &the_alpha_linux_nat_target;
add_inf_child_target (&the_alpha_linux_nat_target);
alpha_linux_gdb_signal_to_target);
}
-void _initialize_alpha_linux_tdep ();
-void
-_initialize_alpha_linux_tdep ()
+INIT_GDB_FILE (alpha_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_LINUX,
alpha_linux_init_abi);
}
\f
-void _initialize_alphanbsd_tdep ();
-void
-_initialize_alphanbsd_tdep ()
+INIT_GDB_FILE (alphanbsd_tdep)
{
/* Even though NetBSD/alpha used ELF since day one, it used the
traditional a.out-style core dump format before NetBSD 1.6, but
}
\f
-void _initialize_alphaobsd_tdep ();
-void
-_initialize_alphaobsd_tdep ()
+INIT_GDB_FILE (alphaobsd_tdep)
{
gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_OPENBSD,
alphaobsd_init_abi);
frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
}
-void _initialize_alpha_tdep ();
-void
-_initialize_alpha_tdep ()
+INIT_GDB_FILE (alpha_tdep)
{
gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, NULL);
get_status_string (status));
}
-extern initialize_file_ftype _initialize_amd_dbgapi_target;
-
void
-_initialize_amd_dbgapi_target ()
+INIT_GDB_FILE (amd_dbgapi_target)
{
/* Make sure the loaded debugger library version is greater than or equal to
the one used to build GDB. */
set_gdbarch_so_ops (gdbarch, &darwin_so_ops);
}
-void _initialize_amd64_darwin_tdep ();
-void
-_initialize_amd64_darwin_tdep ()
+INIT_GDB_FILE (amd64_darwin_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
GDB_OSABI_DARWIN, x86_darwin_init_abi_64);
return GDB_OSABI_UNKNOWN;
}
-void _initialize_amd64_dicos_tdep ();
-void
-_initialize_amd64_dicos_tdep ()
+INIT_GDB_FILE (amd64_dicos_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_elf_flavour,
amd64_dicos_osabi_sniffer);
return i386_target_description (X86_XSTATE_SSE_MASK, true);
}
-void _initialize_amd64fbsd_nat ();
-void
-_initialize_amd64fbsd_nat ()
+INIT_GDB_FILE (amd64fbsd_nat)
{
add_inf_child_target (&the_amd64_fbsd_nat_target);
amd64fbsd_get_thread_local_address);
}
-void _initialize_amd64fbsd_tdep ();
-void
-_initialize_amd64fbsd_tdep ()
+INIT_GDB_FILE (amd64fbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
GDB_OSABI_FREEBSD, amd64fbsd_init_abi);
(gdbarch, svr4_lp64_fetch_link_map_offsets);
}
-void _initialize_amd64_gnu_tdep ();
-void
-_initialize_amd64_gnu_tdep ()
+INIT_GDB_FILE (amd64_gnu_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
GDB_OSABI_HURD, amd64_gnu_init_abi);
return false;
}
-void _initialize_amd64_linux_nat ();
-void
-_initialize_amd64_linux_nat ()
+INIT_GDB_FILE (amd64_linux_nat)
{
amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
(gdbarch, linux_ilp32_fetch_link_map_offsets);
}
-void _initialize_amd64_linux_tdep ();
-void
-_initialize_amd64_linux_tdep ()
+INIT_GDB_FILE (amd64_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
GDB_OSABI_LINUX, amd64_linux_init_abi);
static amd64_bsd_nat_target<nbsd_nat_target> the_amd64_nbsd_nat_target;
-void _initialize_amd64nbsd_nat ();
-void
-_initialize_amd64nbsd_nat ()
+INIT_GDB_FILE (amd64nbsd_nat)
{
amd64_native_gregset32_reg_offset = amd64nbsd32_r_reg_offset;
amd64_native_gregset32_num_regs = ARRAY_SIZE (amd64nbsd32_r_reg_offset);
(gdbarch, svr4_lp64_fetch_link_map_offsets);
}
-void _initialize_amd64nbsd_tdep ();
-void
-_initialize_amd64nbsd_tdep ()
+INIT_GDB_FILE (amd64nbsd_tdep)
{
/* The NetBSD/amd64 native dependent code makes this assumption. */
gdb_assert (ARRAY_SIZE (amd64nbsd_r_reg_offset) == AMD64_NUM_GREGS);
static amd64_bsd_nat_target<obsd_nat_target> the_amd64_obsd_nat_target;
-void _initialize_amd64obsd_nat ();
-void
-_initialize_amd64obsd_nat ()
+INIT_GDB_FILE (amd64obsd_nat)
{
amd64_native_gregset32_reg_offset = amd64obsd32_r_reg_offset;
amd64_native_gregset32_num_regs = ARRAY_SIZE (amd64obsd32_r_reg_offset);
frame_unwind_prepend_unwinder (gdbarch, &amd64obsd_trapframe_unwind);
}
-void _initialize_amd64obsd_tdep ();
-void
-_initialize_amd64obsd_tdep ()
+INIT_GDB_FILE (amd64obsd_tdep)
{
/* The OpenBSD/amd64 native dependent code makes this assumption. */
gdb_assert (ARRAY_SIZE (amd64obsd_r_reg_offset) == AMD64_NUM_GREGS);
(gdbarch, svr4_lp64_fetch_link_map_offsets);
}
-void _initialize_amd64_sol2_tdep ();
-void
-_initialize_amd64_sol2_tdep ()
+INIT_GDB_FILE (amd64_sol2_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64,
GDB_OSABI_SOLARIS, amd64_sol2_init_abi);
} // namespace selftests
#endif /* GDB_SELF_TEST */
-void _initialize_amd64_tdep ();
-void
-_initialize_amd64_tdep ()
+INIT_GDB_FILE (amd64_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_NONE,
amd64_none_init_abi);
return regnum >= AMD64_CS_REGNUM && regnum <= AMD64_GS_REGNUM;
}
-void _initialize_amd64_windows_nat ();
-void
-_initialize_amd64_windows_nat ()
+INIT_GDB_FILE (amd64_windows_nat)
{
x86_set_debug_register_length (8);
}
return GDB_OSABI_UNKNOWN;
}
-void _initialize_amd64_windows_tdep ();
-void
-_initialize_amd64_windows_tdep ()
+INIT_GDB_FILE (amd64_windows_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_WINDOWS,
amd64_windows_init_abi);
#endif
-void _initialize_amdgpu_tdep ();
-
-void
-_initialize_amdgpu_tdep ()
+INIT_GDB_FILE (amdgpu_tdep)
{
gdbarch_register (bfd_arch_amdgcn, amdgpu_gdbarch_init, NULL,
amdgpu_supports_arch_info);
annotate_breakpoints_invalid ();
}
-void _initialize_annotate ();
-void
-_initialize_annotate ()
+INIT_GDB_FILE (annotate)
{
gdb::observers::breakpoint_created.attach (breakpoint_changed, "annotate");
gdb::observers::breakpoint_deleted.attach (breakpoint_changed, "annotate");
}
/* Suppress warning from -Wmissing-prototypes. */
-void _initialize_arc_linux_nat ();
-void
-_initialize_arc_linux_nat ()
+INIT_GDB_FILE (arc_linux_nat)
{
/* Register the target. */
linux_target = &the_arc_linux_nat_target;
linux_ilp32_fetch_link_map_offsets);
}
-/* Suppress warning from -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_arc_linux_tdep;
-
-void
-_initialize_arc_linux_tdep ()
+INIT_GDB_FILE (arc_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_arc, 0, GDB_OSABI_LINUX,
arc_linux_init_osabi);
return GDB_OSABI_UNKNOWN;
}
-void _initialize_arc_newlib_tdep ();
-void
-_initialize_arc_newlib_tdep ()
+INIT_GDB_FILE (arc_newlib_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_arc, bfd_target_elf_flavour,
arc_newlib_osabi_sniffer);
arc_insn_dump (insn);
}
-void _initialize_arc_tdep ();
-void
-_initialize_arc_tdep ()
+INIT_GDB_FILE (arc_tdep)
{
gdbarch_register (bfd_arch_arc, arc_gdbarch_init, arc_dump_tdep);
return e;
}
-void _initialize_gdbarch_utils ();
-void
-_initialize_gdbarch_utils ()
+INIT_GDB_FILE (gdbarch_utils)
{
add_setshow_enum_cmd ("endian", class_support,
endian_enum, &set_endian_string,
return desc;
}
-void _initialize_arm_fbsd_nat ();
-void
-_initialize_arm_fbsd_nat ()
+INIT_GDB_FILE (arm_fbsd_nat)
{
add_inf_child_target (&the_arm_fbsd_nat_target);
}
set_gdbarch_software_single_step (gdbarch, arm_software_single_step);
}
-void _initialize_arm_fbsd_tdep ();
-void
-_initialize_arm_fbsd_tdep ()
+INIT_GDB_FILE (arm_fbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_FREEBSD,
arm_fbsd_init_abi);
*child_state = *parent_state;
}
-void _initialize_arm_linux_nat ();
-void
-_initialize_arm_linux_nat ()
+INIT_GDB_FILE (arm_linux_nat)
{
/* Register the target. */
linux_target = &the_arm_linux_nat_target;
set_gdbarch_gcc_target_options (gdbarch, arm_linux_gcc_target_options);
}
-void _initialize_arm_linux_tdep ();
-void
-_initialize_arm_linux_tdep ()
+INIT_GDB_FILE (arm_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
arm_linux_init_abi);
return arm_read_description (ARM_FP_TYPE_VFPV3, false);
}
-void _initialize_arm_netbsd_nat ();
-void
-_initialize_arm_netbsd_nat ()
+INIT_GDB_FILE (arm_netbsd_nat)
{
add_inf_child_target (&the_arm_netbsd_nat_target);
}
(gdbarch, svr4_ilp32_fetch_link_map_offsets);
}
-void _initialize_arm_netbsd_tdep ();
-void
-_initialize_arm_netbsd_tdep ()
+INIT_GDB_FILE (arm_netbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_NETBSD,
arm_netbsd_elf_init_abi);
/* Initialize ARM bare-metal target support. */
-void _initialize_arm_none_tdep ();
-void
-_initialize_arm_none_tdep ()
+INIT_GDB_FILE (arm_none_tdep)
{
gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_NONE,
arm_none_init_abi);
}
}
-void _initialize_armobsd_tdep ();
-void
-_initialize_armobsd_tdep ()
+INIT_GDB_FILE (armobsd_tdep)
{
gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_OPENBSD,
armobsd_init_abi);
return GDB_OSABI_UNKNOWN;
}
-void _initialize_arm_pikeos_tdep ();
-void
-_initialize_arm_pikeos_tdep ()
+INIT_GDB_FILE (arm_pikeos_tdep)
{
/* Register the sniffer for the PikeOS targets. */
gdbarch_register_osabi_sniffer (bfd_arch_arm, bfd_target_elf_flavour,
}
#endif
-void _initialize_arm_tdep ();
-void
-_initialize_arm_tdep ()
+INIT_GDB_FILE (arm_tdep)
{
long length;
int i, j;
return GDB_OSABI_UNKNOWN;
}
-void _initialize_arm_wince_tdep ();
-void
-_initialize_arm_wince_tdep ()
+INIT_GDB_FILE (arm_wince_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_arm, bfd_target_coff_flavour,
arm_wince_osabi_sniffer);
gdb::observers::token auto_load_new_objfile_observer_token;
-void _initialize_auto_load ();
-void
-_initialize_auto_load ()
+INIT_GDB_FILE (auto_load)
{
struct cmd_list_element *cmd;
gdb::unique_xmalloc_ptr<char> scripts_directory_help, gdb_name_help,
}
}
-void _initialize_auxv ();
-void
-_initialize_auxv ()
+INIT_GDB_FILE (auxv)
{
add_info ("auxv", info_auxv_command,
_("Display the inferior's auxiliary vector.\n\
}
}
-void _initialize_avr_tdep ();
-void
-_initialize_avr_tdep ()
+INIT_GDB_FILE (avr_tdep)
{
gdbarch_register (bfd_arch_avr, avr_gdbarch_init);
/* Initialization code. */
-void _initialize_ax_gdb ();
-void
-_initialize_ax_gdb ()
+INIT_GDB_FILE (ax_gdb)
{
add_cmd ("agent", class_maintenance, maint_agent_command,
_("\
bfin_linux_get_syscall_number);
}
-void _initialize_bfin_linux_tdep ();
-void
-_initialize_bfin_linux_tdep ()
+INIT_GDB_FILE (bfin_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_bfin, 0, GDB_OSABI_LINUX,
bfin_linux_init_abi);
return gdbarch;
}
-void _initialize_bfin_tdep ();
-void
-_initialize_bfin_tdep ()
+INIT_GDB_FILE (bfin_tdep)
{
gdbarch_register (bfd_arch_bfin, bfin_gdbarch_init);
}
\f
-void _initialize_block ();
-void
-_initialize_block ()
+INIT_GDB_FILE (block)
{
add_cmd ("blocks", class_maintenance, maintenance_info_blocks,
_("\
return gdbarch;
}
-void _initialize_bpf_tdep ();
-void
-_initialize_bpf_tdep ()
+INIT_GDB_FILE (bpf_tdep)
{
gdbarch_register (bfd_arch_bpf, bpf_gdbarch_init);
install_breakpoint (0, std::move (c), 1);
}
-void _initialize_break_catch_exec ();
-void
-_initialize_break_catch_exec ()
+INIT_GDB_FILE (break_catch_exec)
{
add_catch_command ("exec", _("Catch calls to exec."),
catch_exec_command_1,
}
}
-void _initialize_break_catch_fork ();
-void
-_initialize_break_catch_fork ()
+INIT_GDB_FILE (break_catch_fork)
{
add_catch_command ("fork", _("Catch calls to fork."),
catch_fork_command_1,
catch_load_or_unload (arg, from_tty, 0, command);
}
-void _initialize_break_catch_load ();
-void
-_initialize_break_catch_load ()
+INIT_GDB_FILE (break_catch_load)
{
add_catch_command ("load", _("Catch loads of shared libraries.\n\
Usage: catch load [REGEX]\n\
create_signal_catchpoint (tempflag, std::move (filter), catch_all);
}
-void _initialize_break_catch_sig ();
-void
-_initialize_break_catch_sig ()
+INIT_GDB_FILE (break_catch_sig)
{
add_catch_command ("signal", _("\
Catch signals by their names and/or numbers.\n\
inf_data->syscalls_counts.clear ();
}
-void _initialize_break_catch_syscall ();
-void
-_initialize_break_catch_syscall ()
+INIT_GDB_FILE (break_catch_syscall)
{
gdb::observers::inferior_exit.attach (clear_syscall_counts,
"break-catch-syscall");
\f
-void _initialize_break_catch_throw ();
-void
-_initialize_break_catch_throw ()
+INIT_GDB_FILE (break_catch_throw)
{
/* Add catch and tcatch sub-commands. */
add_catch_command ("catch", _("\
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
-void _initialize_break_cond_parse ();
-void
-_initialize_break_cond_parse ()
+INIT_GDB_FILE (break_cond_parse)
{
#if GDB_SELF_TEST
selftests::register_test
cmd_list_element *commands_cmd_element = nullptr;
-void _initialize_breakpoint ();
-void
-_initialize_breakpoint ()
+INIT_GDB_FILE (breakpoint)
{
struct cmd_list_element *c;
return normal_pid_to_str (ptid);
}
-void _initialize_bsd_uthread ();
-void
-_initialize_bsd_uthread ()
+INIT_GDB_FILE (bsd_uthread)
{
gdb::observers::inferior_created.attach (bsd_uthread_inferior_created,
"bsd-uthread");
/* Initialize btrace maintenance commands. */
-void _initialize_btrace ();
-void
-_initialize_btrace ()
+INIT_GDB_FILE (btrace)
{
add_cmd ("btrace", class_maintenance, maint_info_btrace_cmd,
_("Info about branch tracing data."), &maintenanceinfolist);
#endif /* USE_INTERMEDIATE_ENCODING_FUNCTION */
-void _initialize_charset ();
-void
-_initialize_charset ()
+INIT_GDB_FILE (charset)
{
/* The first element is always "auto". */
charsets.charsets.push_back (xstrdup ("auto"));
return value::allocate_optimized_out (int_type);
}
-void _initialize_cli_cmds ();
-void
-_initialize_cli_cmds ()
+INIT_GDB_FILE (cli_cmds)
{
struct cmd_list_element *c;
}
}
-void _initialize_cli_dump ();
-void
-_initialize_cli_dump ()
+INIT_GDB_FILE (cli_dump)
{
struct cmd_list_element *c;
/* Standard gdb initialization hook. */
-void _initialize_cli_interp ();
-void
-_initialize_cli_interp ()
+INIT_GDB_FILE (cli_interp)
{
interp_factory_register (INTERP_CONSOLE, cli_interp_factory);
}
gdb_printf (file, _("off: Logging is disabled.\n"));
}
-void _initialize_cli_logging ();
-void
-_initialize_cli_logging ()
+INIT_GDB_FILE (cli_logging)
{
static struct cmd_list_element *set_logging_cmdlist, *show_logging_cmdlist;
}
-void _initialize_cli_script ();
-void
-_initialize_cli_script ()
+INIT_GDB_FILE (cli_script)
{
struct cmd_list_element *c;
gdb_puts (error_prefix.c_str (), file);
}
-void _initialize_cli_style ();
-void
-_initialize_cli_style ()
+INIT_GDB_FILE (cli_style)
{
add_setshow_prefix_cmd ("style", no_class,
_("\
/* Adds "Set/show debug coff_pe_read" commands. */
-void _initialize_coff_pe_read ();
-void
-_initialize_coff_pe_read ()
+INIT_GDB_FILE (coff_pe_read)
{
add_setshow_zuinteger_cmd ("coff-pe-read", class_maintenance,
&debug_coff_pe_read,
NULL, /* sym_probe_fns */
};
-void _initialize_coffread ();
-void
-_initialize_coffread ()
+INIT_GDB_FILE (coffread)
{
add_symtab_fns (bfd_target_coff_flavour, &coff_sym_fns);
return pop_binding_level ();
}
-void _initialize_compile_cplus_types ();
-void
-_initialize_compile_cplus_types ()
+INIT_GDB_FILE (compile_cplus_types)
{
add_setshow_boolean_cmd ("compile-cplus-types", no_class,
&debug_compile_cplus_types, _("\
/* See compile.h. */
cmd_list_element *compile_cmd_element = nullptr;
-void _initialize_compile ();
-void
-_initialize_compile ()
+INIT_GDB_FILE (compile)
{
compile_cmd_element = add_prefix_cmd ("compile", class_obscure,
compile_command,
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
-void _initialize_complaints ();
-void
-_initialize_complaints ()
+INIT_GDB_FILE (complaints)
{
add_setshow_zinteger_cmd ("complaints", class_support,
&stop_whining, _("\
return false;
}
-void _initialize_completer ();
-void
-_initialize_completer ()
+INIT_GDB_FILE (completer)
{
/* Setup some readline completion globals. */
rl_completion_word_break_hook = gdb_completion_word_break_characters;
gdb_printf ("\n");
}
-void _initialize_copying ();
-void
-_initialize_copying ()
+INIT_GDB_FILE (copying)
{
add_cmd ("copying", no_set_class, show_copying_command,
_("Conditions for redistributing copies of GDB."),
set_gnutarget_command (NULL, 0, NULL);
}
-void _initialize_core ();
-void
-_initialize_core ()
+INIT_GDB_FILE (core)
{
cmd_list_element *core_file_cmd
= add_cmd ("core-file", class_files, core_file_command, _("\
return targ->lookup_mapped_file_info (filename, addr);
}
-void _initialize_corelow ();
-void
-_initialize_corelow ()
+INIT_GDB_FILE (corelow)
{
add_target (core_target_info, core_target_open,
filename_maybe_quoted_completer);
uiout->text (").\n");
}
-void _initialize_cp_abi ();
-void
-_initialize_cp_abi ()
+INIT_GDB_FILE (cp_abi)
{
struct cmd_list_element *c;
#endif
-void _initialize_cp_name_parser ();
-void
-_initialize_cp_name_parser ()
+INIT_GDB_FILE (cp_name_parser)
{
#if GDB_SELF_TEST
selftests::register_test ("canonicalize", canonicalize_tests);
gdb_printf (_("The `maint namespace' command was removed.\n"));
}
-void _initialize_cp_namespace ();
-void
-_initialize_cp_namespace ()
+INIT_GDB_FILE (cp_namespace)
{
struct cmd_list_element *cmd;
return 0;
}
-void _initialize_cp_support ();
-void
-_initialize_cp_support ()
+INIT_GDB_FILE (cp_support)
{
cmd_list_element *maintenance_cplus
= add_basic_prefix_cmd ("cplus", class_maintenance,
#endif
-void _initialize_cp_valprint ();
-void
-_initialize_cp_valprint ()
+INIT_GDB_FILE (cp_valprint)
{
#if GDB_SELF_TEST
selftests::register_test_foreach_arch ("print-fields", test_print_fields);
}
-void _initialize_cris_linux_tdep ();
-void
-_initialize_cris_linux_tdep ()
+INIT_GDB_FILE (cris_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_cris, 0, GDB_OSABI_LINUX,
cris_linux_init_abi);
&cris_regset, NULL, cb_data);
}
-void _initialize_cris_tdep ();
-void
-_initialize_cris_tdep ()
+INIT_GDB_FILE (cris_tdep)
{
gdbarch_register (bfd_arch_cris, cris_gdbarch_init, cris_dump_tdep);
&csky_linux_rt_sigreturn_tramp_frame_kernel_4x);
}
-void _initialize_csky_linux_tdep ();
-void
-_initialize_csky_linux_tdep ()
+INIT_GDB_FILE (csky_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_csky, 0, GDB_OSABI_LINUX,
csky_linux_init_abi);
return gdbarch;
}
-void _initialize_csky_tdep ();
-void
-_initialize_csky_tdep ()
+INIT_GDB_FILE (csky_tdep)
{
gdbarch_register (bfd_arch_csky, csky_gdbarch_init);
}
}
-void _initialize_darwin_info_commands ();
-void
-_initialize_darwin_info_commands ()
+INIT_GDB_FILE (darwin_info_commands)
{
add_info ("mach-tasks", info_mach_tasks_command,
_("Get list of tasks in system."));
return true;
}
-void _initialize_darwin_nat ();
-void
-_initialize_darwin_nat ()
+INIT_GDB_FILE (darwin_nat)
{
kern_return_t kret;
NULL, /* sym_probe_fns */
};
-void _initialize_dbxread ();
-void
-_initialize_dbxread ()
+INIT_GDB_FILE (dbxread)
{
add_symtab_fns (bfd_target_aout_flavour, &aout_sym_fns);
}
target_dcache_invalidate (current_program_space->aspace);
}
-void _initialize_dcache ();
-void
-_initialize_dcache ()
+INIT_GDB_FILE (dcache)
{
add_setshow_boolean_cmd ("remotecache", class_support,
&dcache_enabled_p, _("\
/* Register debuginfod commands. */
-void _initialize_debuginfod ();
-void
-_initialize_debuginfod ()
+INIT_GDB_FILE (debuginfod)
{
/* set/show debuginfod */
add_setshow_prefix_cmd ("debuginfod", class_run,
/* From top.c */
-typedef void initialize_file_ftype (void);
-
extern char *gdb_readline_wrapper (const char *);
extern const char *command_line_input (std::string &cmd_line_buffer,
#include "utils.h"
+/* File initialization macro. This is found by make-init-c and used
+ to construct the gdb initialization function. */
+#define INIT_GDB_FILE(NAME) \
+ extern void _initialize_ ## NAME (); \
+ void _initialize_ ## NAME ()
+
#endif /* GDB_DEFS_H */
} /* namespace selftests */
-void _initialize_disasm_selftests ();
-void
-_initialize_disasm_selftests ()
+INIT_GDB_FILE (disasm_selftests)
{
selftests::register_test_foreach_arch ("print_one_insn",
selftests::print_one_insn_test);
/* Initialization code. */
-void _initialize_disasm ();
-void
-_initialize_disasm ()
+INIT_GDB_FILE (disasm)
{
/* Add the command that controls the disassembler options. */
set_show_commands set_show_disas_opts
}
}
-void _initialize_displaced_stepping ();
-void
-_initialize_displaced_stepping ()
+INIT_GDB_FILE (displaced_stepping)
{
add_setshow_boolean_cmd ("displaced", class_maintenance,
&debug_displaced, _("\
info_probes_for_spops (arg, from_tty, &dtrace_static_probe_ops);
}
-void _initialize_dtrace_probe ();
-void
-_initialize_dtrace_probe ()
+INIT_GDB_FILE (dtrace_probe)
{
all_static_probe_ops.push_back (&dtrace_static_probe_ops);
}
}
-void _initialize_dummy_frame ();
-void
-_initialize_dummy_frame ()
+INIT_GDB_FILE (dummy_frame)
{
add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
_("Print the contents of the internal dummy-frame stack."),
obstack_grow (storage, sep, strlen (sep));
}
-void _initialize_dwarf2_entry ();
-void
-_initialize_dwarf2_entry ()
+INIT_GDB_FILE (dwarf2_entry)
{
#if GDB_SELF_TEST
selftests::register_test ("cooked_index_entry::compare", test_compare);
wait_for_index_cache (0);
}
-void _initialize_cooked_index ();
-void
-_initialize_cooked_index ()
+INIT_GDB_FILE (cooked_index)
{
add_cmd ("wait-for-index-cache", class_maintenance,
maintenance_wait_for_index_cache, _("\
tailcall_frame_prev_arch
);
-void _initialize_tailcall_frame ();
-void
-_initialize_tailcall_frame ()
+INIT_GDB_FILE (tailcall_frame)
{
cache_htab = htab_create_alloc (50, cache_hash, cache_eq, NULL, xcalloc,
xfree);
set_comp_unit (objfile, unit.release ());
}
-void _initialize_dwarf2_frame ();
-void
-_initialize_dwarf2_frame ()
+INIT_GDB_FILE (dwarf2_frame)
{
#if GDB_SELF_TEST
selftests::register_test_foreach_arch ("execute_cfa_program",
indent, global_index_cache.n_misses ());
}
-void _initialize_index_cache ();
-void
-_initialize_index_cache ()
+INIT_GDB_FILE (index_cache)
{
/* Set the default index cache directory. */
std::string cache_dir = get_standard_cache_dir ();
} /* selftests namespace. */
#endif
-void _initialize_dwarf_index_write ();
-void
-_initialize_dwarf_index_write ()
+INIT_GDB_FILE (dwarf_index_write)
{
#if GDB_SELF_TEST
selftests::register_test ("gdb_index", selftests::gdb_index);
loclist_generate_c_location
};
-void _initialize_dwarf2loc ();
-void
-_initialize_dwarf2loc ()
+INIT_GDB_FILE (dwarf2loc)
{
add_setshow_zuinteger_cmd ("entry-values", class_maintenance,
&entry_values_debug,
return true;
}
-void _initialize_read_gdb_index ();
-
-void
-_initialize_read_gdb_index ()
+INIT_GDB_FILE (read_gdb_index)
{
add_setshow_boolean_cmd ("use-deprecated-index-sections",
no_class, &use_deprecated_index_sections, _("\
value);
}
-void _initialize_dwarf2_read ();
-void
-_initialize_dwarf2_read ()
+INIT_GDB_FILE (dwarf2_read)
{
add_setshow_prefix_cmd ("dwarf", class_maintenance,
_("\
elf_gnu_ifunc_resolver_return_stop
};
-void _initialize_elfread ();
-void
-_initialize_elfread ()
+INIT_GDB_FILE (elfread)
{
add_symtab_fns (bfd_target_elf_flavour, &elf_sym_fns);
gdb_printf (file, _("Event loop debugging is %s.\n"), value);
}
-void _initialize_event_top ();
-void
-_initialize_event_top ()
+INIT_GDB_FILE (event_top)
{
add_setshow_enum_cmd ("event-loop", class_maintenance,
debug_event_loop_enum,
return objfile_find_memory_regions (this, func, data);
}
-void _initialize_exec ();
-void
-_initialize_exec ()
+INIT_GDB_FILE (exec)
{
struct cmd_list_element *c;
}
}
-void _initialize_extension ();
-void
-_initialize_extension ()
+INIT_GDB_FILE (extension)
{
gdb::observers::before_prompt.attach (ext_lang_before_prompt, "extension");
}
#endif
-void _initialize_extract_store_integer ();
-void
-_initialize_extract_store_integer ()
+INIT_GDB_FILE (extract_store_integer)
{
#if GDB_SELF_TEST
selftests::register_test ("copy_integer_to_size",
static struct cmd_list_element *set_fortran_list;
static struct cmd_list_element *show_fortran_list;
-void _initialize_f_language ();
-void
-_initialize_f_language ()
+INIT_GDB_FILE (f_language)
{
add_setshow_prefix_cmd
("fortran", no_class,
}
}
-void _initialize_f_valprint ();
-void
-_initialize_f_valprint ()
+INIT_GDB_FILE (f_valprint)
{
add_info ("common", info_common_command,
_("Print out the values contained in a Fortran COMMON block."));
return (true);
}
-void _initialize_fbsd_nat ();
-void
-_initialize_fbsd_nat ()
+INIT_GDB_FILE (fbsd_nat)
{
add_setshow_boolean_cmd ("fbsd-lwp", class_maintenance,
&debug_fbsd_lwp, _("\
value);
}
-void _initialize_filesystem ();
-void
-_initialize_filesystem ()
+INIT_GDB_FILE (filesystem)
{
add_setshow_enum_cmd ("target-file-system-kind",
class_files,
found_count > 1 ? "s" : "");
}
-void _initialize_mem_search ();
-void
-_initialize_mem_search ()
+INIT_GDB_FILE (mem_search)
{
add_cmd ("find", class_vars, find_command, _("\
Search memory for a sequence of bytes.\n\
value);
}
-void _initialize_fork_child ();
-void
-_initialize_fork_child ()
+INIT_GDB_FILE (fork_child)
{
add_setshow_filename_cmd ("exec-wrapper", class_run, &exec_wrapper, _("\
Set a wrapper for running programs.\n\
enable_disable_frame_unwinders (args, from_tty, true);
}
-void _initialize_frame_unwind ();
-void
-_initialize_frame_unwind ()
+INIT_GDB_FILE (frame_unwind)
{
/* Add "maint info frame-unwinders". */
add_cmd ("frame-unwinders",
return m_ptr;
}
-void _initialize_frame ();
-void
-_initialize_frame ()
+INIT_GDB_FILE (frame)
{
obstack_init (&frame_cache_obstack);
return GDB_OSABI_UNKNOWN;
}
-void _initialize_frv_linux_tdep ();
-void
-_initialize_frv_linux_tdep ()
+INIT_GDB_FILE (frv_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX,
frv_linux_init_abi);
return gdbarch;
}
-void _initialize_frv_tdep ();
-void
-_initialize_frv_tdep ()
+INIT_GDB_FILE (frv_tdep)
{
gdbarch_register (bfd_arch_frv, frv_gdbarch_init);
}
/* Register this machine's init routine. */
-void _initialize_ft32_tdep ();
-void
-_initialize_ft32_tdep ()
+INIT_GDB_FILE (ft32_tdep)
{
gdbarch_register (bfd_arch_ft32, ft32_gdbarch_init);
}
return nullptr;
}
-void _initialize_gcore ();
-void
-_initialize_gcore ()
+INIT_GDB_FILE (gcore)
{
cmd_list_element *generate_core_file_cmd
= add_com ("generate-core-file", class_files, gcore_command, _("\
error (_("Can't demangle \"%s\""), name);
}
-void _initialize_gdb_demangle ();
-void
-_initialize_gdb_demangle ()
+INIT_GDB_FILE (gdb_demangle)
{
int i, ndems;
error (_("fatal error: libbfd ABI mismatch"));
}
-void _initialize_gdb_bfd ();
-void
-_initialize_gdb_bfd ()
+INIT_GDB_FILE (gdb_bfd)
{
add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
List the BFDs that are currently open."),
} /* namespace selftests */
-void _initialize_gdbarch_selftests ();
-void
-_initialize_gdbarch_selftests ()
+INIT_GDB_FILE (gdbarch_selftests)
{
selftests::register_test_foreach_arch ("register_to_value",
selftests::register_to_value_test);
#endif
}
-void _initialize_gdbtypes ();
-void
-_initialize_gdbtypes ()
+INIT_GDB_FILE (gdbtypes)
{
add_setshow_zuinteger_cmd ("overload", no_class, &overload_debug,
_("Set debugging of C++ overloading."),
xfree (ptr);
}
-void _initialize_gmp_utils ();
-
-void
-_initialize_gmp_utils ()
+INIT_GDB_FILE (gmp_utils)
{
/* Tell GMP to use GDB's memory management routines. */
mp_set_memory_functions (xmalloc, xrealloc_for_gmp, xfree_for_gmp);
&thread_cmd_list);
}
-void _initialize_gnu_nat ();
-void
-_initialize_gnu_nat ()
+INIT_GDB_FILE (gnu_nat)
{
proc_server = getproc ();
gnu_v2_abi_ops.baseclass_offset = gnuv2_baseclass_offset;
}
-void _initialize_gnu_v2_abi ();
-void
-_initialize_gnu_v2_abi ()
+INIT_GDB_FILE (gnu_v2_abi)
{
init_gnuv2_ops ();
register_cp_abi (&gnu_v2_abi_ops);
gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
}
-void _initialize_gnu_v3_abi ();
-void
-_initialize_gnu_v3_abi ()
+INIT_GDB_FILE (gnu_v3_abi)
{
init_gnuv3_ops ();
static struct cmd_list_element *info_dos_cmdlist = NULL;
-void _initialize_go32_nat ();
-void
-_initialize_go32_nat ()
+INIT_GDB_FILE (go32_nat)
{
x86_dr_low.set_control = go32_set_dr7;
x86_dr_low.set_addr = go32_set_dr;
&set_guile_list, &show_guile_list);
}
-void _initialize_guile ();
-void
-_initialize_guile ()
+INIT_GDB_FILE (guile)
{
install_gdb_commands ();
}
}
-void _initialize_h8300_tdep ();
-void
-_initialize_h8300_tdep ()
+INIT_GDB_FILE (h8300_tdep)
{
gdbarch_register (bfd_arch_h8300, h8300_gdbarch_init);
}
}
}
-void _initialize_hppa_linux_nat ();
-void
-_initialize_hppa_linux_nat ()
+INIT_GDB_FILE (hppa_linux_nat)
{
/* Register the target. */
linux_target = &the_hppa_linux_nat_target;
svr4_fetch_objfile_link_map);
}
-void _initialize_hppa_linux_tdep ();
-void
-_initialize_hppa_linux_tdep ()
+INIT_GDB_FILE (hppa_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX,
hppa_linux_init_abi);
}
}
-void _initialize_hppanbsd_nat ();
-void
-_initialize_hppanbsd_nat ()
+INIT_GDB_FILE (hppanbsd_nat)
{
add_inf_child_target (&the_hppa_nbsd_nat_target);
}
tramp_frame_prepend_unwinder (gdbarch, &hppanbsd_sigtramp_si4);
}
-void _initialize_hppanbsd_tdep ();
-void
-_initialize_hppanbsd_tdep ()
+INIT_GDB_FILE (hppanbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_NETBSD,
hppanbsd_init_abi);
}
}
-void _initialize_hppaobsd_nat ();
-void
-_initialize_hppaobsd_nat ()
+INIT_GDB_FILE (hppaobsd_nat)
{
add_inf_child_target (&the_hppa_obsd_nat_target);
}
(gdbarch, hppaobsd_iterate_over_regset_sections);
}
-void _initialize_hppabsd_tdep ();
-void
-_initialize_hppabsd_tdep ()
+INIT_GDB_FILE (hppabsd_tdep)
{
gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_OPENBSD,
hppaobsd_init_abi);
gdb_printf (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
}
-void _initialize_hppa_tdep ();
-void
-_initialize_hppa_tdep ()
+INIT_GDB_FILE (hppa_tdep)
{
gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
}
}
-void _initialize_i386bsd_nat ();
-void
-_initialize_i386bsd_nat ()
+INIT_GDB_FILE (i386bsd_nat)
{
/* To support the recognition of signal handlers, i386-bsd-tdep.c
hardcodes some constants. Inclusion of this file means that we
}
}
-void _initialize_i386_darwin_nat ();
-void
-_initialize_i386_darwin_nat ()
+INIT_GDB_FILE (i386_darwin_nat)
{
#ifdef BFD64
amd64_native_gregset64_reg_offset = amd64_darwin_thread_state_reg_offset;
return GDB_OSABI_UNKNOWN;
}
-void _initialize_i386_darwin_tdep ();
-void
-_initialize_i386_darwin_tdep ()
+INIT_GDB_FILE (i386_darwin_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_unknown, bfd_target_mach_o_flavour,
i386_mach_o_osabi_sniffer);
return GDB_OSABI_UNKNOWN;
}
-void _initialize_i386_dicos_tdep ();
-void
-_initialize_i386_dicos_tdep ()
+INIT_GDB_FILE (i386_dicos_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_elf_flavour,
i386_dicos_osabi_sniffer);
return i386_target_description (X86_XSTATE_X87_MASK, true);
}
-void _initialize_i386fbsd_nat ();
-void
-_initialize_i386fbsd_nat ()
+INIT_GDB_FILE (i386fbsd_nat)
{
add_inf_child_target (&the_i386_fbsd_nat_target);
i386fbsd_get_thread_local_address);
}
-void _initialize_i386fbsd_tdep ();
-void
-_initialize_i386fbsd_tdep ()
+INIT_GDB_FILE (i386fbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_FREEBSD,
i386fbsd_init_abi);
tdep->sc_num_regs = ARRAY_SIZE (i386_gnu_sc_reg_offset);
}
-void _initialize_i386gnu_tdep ();
-void
-_initialize_i386gnu_tdep ()
+INIT_GDB_FILE (i386gnu_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_HURD, i386gnu_init_abi);
}
}
\f
-void _initialize_i386_go32_tdep ();
-void
-_initialize_i386_go32_tdep ()
+INIT_GDB_FILE (i386_go32_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour,
i386_coff_osabi_sniffer);
perror_with_name (("ptrace"));
}
-void _initialize_i386_linux_nat ();
-void
-_initialize_i386_linux_nat ()
+INIT_GDB_FILE (i386_linux_nat)
{
linux_target = &the_i386_linux_nat_target;
i386_linux_get_syscall_number);
}
-void _initialize_i386_linux_tdep ();
-void
-_initialize_i386_linux_tdep ()
+INIT_GDB_FILE (i386_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX,
i386_linux_init_abi);
static i386_bsd_nat_target<nbsd_nat_target> the_i386_nbsd_nat_target;
-void _initialize_i386nbsd_nat ();
-void
-_initialize_i386nbsd_nat ()
+INIT_GDB_FILE (i386nbsd_nat)
{
add_inf_child_target (&the_i386_nbsd_nat_target);
tdep->struct_return = pcc_struct_return;
}
-void _initialize_i386nbsd_tdep ();
-void
-_initialize_i386nbsd_tdep ()
+INIT_GDB_FILE (i386nbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_NETBSD,
i386nbsdelf_init_abi);
static i386_bsd_nat_target<obsd_nat_target> the_i386_obsd_nat_target;
-void _initialize_i386obsd_nat ();
-void
-_initialize_i386obsd_nat ()
+INIT_GDB_FILE (i386obsd_nat)
{
add_inf_child_target (&i386_obsd_nat_target);
(gdbarch, svr4_ilp32_fetch_link_map_offsets);
}
-void _initialize_i386obsd_tdep ();
-void
-_initialize_i386obsd_tdep ()
+INIT_GDB_FILE (i386obsd_tdep)
{
gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_OPENBSD,
i386obsd_init_abi);
#endif
-void _initialize_amd64_sol2_nat ();
-void
-_initialize_amd64_sol2_nat ()
+INIT_GDB_FILE (amd64_sol2_nat)
{
#if PR_MODEL_NATIVE == PR_MODEL_LP64
amd64_native_gregset32_reg_offset = amd64_sol2_gregset32_reg_offset;
return GDB_OSABI_UNKNOWN;
}
-void _initialize_i386_sol2_tdep ();
-void
-_initialize_i386_sol2_tdep ()
+INIT_GDB_FILE (i386_sol2_tdep)
{
/* Register an ELF OS ABI sniffer for Solaris 2 binaries. */
gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_elf_flavour,
return *tdesc;
}
-void _initialize_i386_tdep ();
-void
-_initialize_i386_tdep ()
+INIT_GDB_FILE (i386_tdep)
{
gdbarch_register (bfd_arch_i386, i386_gdbarch_init);
return regnum >= I386_CS_REGNUM && regnum <= I386_GS_REGNUM;
}
-void _initialize_i386_windows_nat ();
-void
-_initialize_i386_windows_nat ()
+INIT_GDB_FILE (i386_windows_nat)
{
#ifndef __x86_64__
x86_set_debug_register_length (4);
return GDB_OSABI_UNKNOWN;
}
-void _initialize_i386_windows_tdep ();
-void
-_initialize_i386_windows_tdep ()
+INIT_GDB_FILE (i386_windows_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour,
i386_windows_osabi_sniffer);
return libunwind_initialized;
}
-void _initialize_libunwind_frame ();
-void
-_initialize_libunwind_frame ()
+INIT_GDB_FILE (libunwind_frame)
{
libunwind_initialized = libunwind_load ();
}
|| WSTOPSIG (status) == SIGILL);
}
-void _initialize_ia64_linux_nat ();
-void
-_initialize_ia64_linux_nat ()
+INIT_GDB_FILE (ia64_linux_nat)
{
/* Register the target. */
linux_target = &the_ia64_linux_nat_target;
ia64_linux_stap_is_single_operand);
}
-void _initialize_ia64_linux_tdep ();
-void
-_initialize_ia64_linux_tdep ()
+INIT_GDB_FILE (ia64_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_ia64, 0, GDB_OSABI_LINUX,
ia64_linux_init_abi);
return gdbarch;
}
-void _initialize_ia64_tdep ();
-void
-_initialize_ia64_tdep ()
+INIT_GDB_FILE (ia64_tdep)
{
gdbarch_register (bfd_arch_ia64, ia64_gdbarch_init, NULL);
}
#endif
}
-void _initialize_ia64_vms_tdep ();
-void
-_initialize_ia64_vms_tdep ()
+INIT_GDB_FILE (ia64_vms_tdep)
{
gdbarch_register_osabi (bfd_arch_ia64, 0, GDB_OSABI_OPENVMS,
ia64_openvms_init_abi);
gdb_assert_not_reached ("... should not be here");
}
-void _initialize_infcall ();
-void
-_initialize_infcall ()
+INIT_GDB_FILE (infcall)
{
add_setshow_boolean_cmd ("may-call-functions", no_class,
&may_call_functions_p, _("\
\n\
To start the inferior without using a shell, use \"set startup-with-shell off\"."
-void _initialize_infcmd ();
-void
-_initialize_infcmd ()
+INIT_GDB_FILE (infcmd)
{
static struct cmd_list_element *info_proc_cmdlist;
struct cmd_list_element *c = nullptr;
stdin_serial = serial_fdopen (0);
}
-void _initialize_inflow ();
-void
-_initialize_inflow ()
+INIT_GDB_FILE (inflow)
{
add_info ("terminal", info_terminal_command,
_("Print inferior's saved terminal status."));
#endif /* GDB_SELF_TEST */
-void _initialize_infrun ();
-void
-_initialize_infrun ()
+INIT_GDB_FILE (infrun)
{
struct cmd_list_element *c;
\f
-void _initialize_inline_frame ();
-void
-_initialize_inline_frame ()
+INIT_GDB_FILE (inline_frame)
{
add_cmd ("inline-frames", class_maintenance, maintenance_info_inline_frames,
_("\
}
/* This just adds the "interpreter-exec" command. */
-void _initialize_interpreter ();
-void
-_initialize_interpreter ()
+INIT_GDB_FILE (interpreter)
{
struct cmd_list_element *c;
Initializer function for the iq2000 module.
Called by gdb at start-up. */
-void _initialize_iq2000_tdep ();
-void
-_initialize_iq2000_tdep ()
+INIT_GDB_FILE (iq2000_tdep)
{
gdbarch_register (bfd_arch_iq2000, iq2000_gdbarch_init);
}
jit_reader_dir.c_str ()));
}
-void _initialize_jit ();
-void
-_initialize_jit ()
+INIT_GDB_FILE (jit)
{
jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
JIT_READER_DIR_RELOCATABLE);
/* Initialize the language routines. */
-void _initialize_language ();
-void
-_initialize_language ()
+INIT_GDB_FILE (language)
{
static const char *const type_or_range_names[]
= { "on", "off", "warn", "auto", NULL };
linux_fork_context (fp, from_tty, inf);
}
-void _initialize_linux_fork ();
-void
-_initialize_linux_fork ()
+INIT_GDB_FILE (linux_fork)
{
/* Checkpoint command: create a fork of the inferior process
and set it aside for later debugging. */
}
}
-void _initialize_linux_nat ();
-void
-_initialize_linux_nat ()
+INIT_GDB_FILE (linux_nat)
{
add_setshow_boolean_cmd ("linux-nat", class_maintenance,
&debug_linux_nat, _("\
linux_corefile_parse_exec_context);
}
-void _initialize_linux_tdep ();
-void
-_initialize_linux_tdep ()
+INIT_GDB_FILE (linux_tdep)
{
/* Observers used to invalidate the cache when needed. */
gdb::observers::inferior_exit.attach (invalidate_linux_cache_inf,
check_thread_db (info, true);
}
-void _initialize_thread_db ();
-void
-_initialize_thread_db ()
+INIT_GDB_FILE (thread_db)
{
/* Defer loading of libthread_db.so until inferior is running.
This allows gdb to load correct libthread_db for a given
return gdbarch;
}
-void _initialize_lm32_tdep ();
-void
-_initialize_lm32_tdep ()
+INIT_GDB_FILE (lm32_tdep)
{
gdbarch_register (bfd_arch_lm32, lm32_gdbarch_init);
}
/* Initialize LoongArch Linux native support. */
-void _initialize_loongarch_linux_nat ();
-void
-_initialize_loongarch_linux_nat ()
+INIT_GDB_FILE (loongarch_linux_nat)
{
linux_target = &the_loongarch_linux_nat_target;
add_inf_child_target (&the_loongarch_linux_nat_target);
/* Initialize LoongArch Linux target support. */
-void _initialize_loongarch_linux_tdep ();
-void
-_initialize_loongarch_linux_tdep ()
+INIT_GDB_FILE (loongarch_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_loongarch, bfd_mach_loongarch32,
GDB_OSABI_LINUX, loongarch_linux_init_abi);
return ret;
}
-void _initialize_loongarch_tdep ();
-void
-_initialize_loongarch_tdep ()
+INIT_GDB_FILE (loongarch_tdep)
{
gdbarch_register (bfd_arch_loongarch, loongarch_gdbarch_init, nullptr);
}
return gdbarch;
}
-void _initialize_m32c_tdep ();
-void
-_initialize_m32c_tdep ()
+INIT_GDB_FILE (m32c_tdep)
{
gdbarch_register (bfd_arch_m32c, m32c_gdbarch_init);
internal_error (_("Got request to store bad register number %d."), regno);
}
-void _initialize_m32r_linux_nat ();
-void
-_initialize_m32r_linux_nat ()
+INIT_GDB_FILE (m32r_linux_nat)
{
/* Register the target. */
linux_target = &the_m32r_linux_nat_target;
svr4_fetch_objfile_link_map);
}
-void _initialize_m32r_linux_tdep ();
-void
-_initialize_m32r_linux_tdep ()
+INIT_GDB_FILE (m32r_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_m32r, 0, GDB_OSABI_LINUX,
m32r_linux_init_abi);
return gdbarch;
}
-void _initialize_m32r_tdep ();
-void
-_initialize_m32r_tdep ()
+INIT_GDB_FILE (m32r_tdep)
{
gdbarch_register (bfd_arch_m32r, m32r_gdbarch_init);
}
return gdbarch;
}
-void _initialize_m68hc11_tdep ();
-void
-_initialize_m68hc11_tdep ()
+INIT_GDB_FILE (m68hc11_tdep)
{
gdbarch_register (bfd_arch_m68hc11, m68hc11_gdbarch_init);
gdbarch_register (bfd_arch_m68hc12, m68hc11_gdbarch_init);
return 1;
}
-void _initialize_m68kbsd_nat ();
-void
-_initialize_m68kbsd_nat ()
+INIT_GDB_FILE (m68kbsd_nat)
{
add_inf_child_target (&the_m68k_bsd_nat_target);
(gdbarch, svr4_ilp32_fetch_link_map_offsets);
}
-void _initialize_m68kbsd_tdep ();
-void
-_initialize_m68kbsd_tdep ()
+INIT_GDB_FILE (m68kbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_m68k, 0, GDB_OSABI_NETBSD,
m68kbsd_init_abi);
return PS_OK;
}
-void _initialize_m68k_linux_nat ();
-void
-_initialize_m68k_linux_nat ()
+INIT_GDB_FILE (m68k_linux_nat)
{
/* Register the target. */
linux_target = &the_m68k_linux_nat_target;
svr4_fetch_objfile_link_map);
}
-void _initialize_m68k_linux_tdep ();
-void
-_initialize_m68k_linux_tdep ()
+INIT_GDB_FILE (m68k_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_m68k, 0, GDB_OSABI_LINUX,
m68k_linux_init_abi);
return osabi;
}
-void _initialize_m68k_tdep ();
-void
-_initialize_m68k_tdep ()
+INIT_GDB_FILE (m68k_tdep)
{
gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
NULL, /* sym_get_probes */
};
-void _initialize_machoread ();
-void
-_initialize_machoread ()
+INIT_GDB_FILE (machoread)
{
add_symtab_fns (bfd_target_mach_o_flavour, &macho_sym_fns);
/* Initializing the `macrocmd' module. */
-void _initialize_macrocmd ();
-void
-_initialize_macrocmd ()
+INIT_GDB_FILE (macrocmd)
{
/* We introduce a new command prefix, `macro', under which we'll put
the various commands for working with preprocessor macros. */
return result;
}
-void _initialize_macroscope ();
-void
-_initialize_macroscope ()
+INIT_GDB_FILE (macroscope)
{
macro_user_macros = new_macro_table (NULL, NULL, NULL);
macro_set_main (macro_user_macros, "<user-defined>");
static cmd_list_element *maintenance_test_options_list;
\f
-void _initialize_maint_test_options ();
-void
-_initialize_maint_test_options ()
+INIT_GDB_FILE (maint_test_options)
{
cmd_list_element *cmd;
}
\f
-void _initialize_maint_test_settings ();
-void
-_initialize_maint_test_settings ()
+INIT_GDB_FILE (maint_test_settings)
{
maintenance_test_settings_filename = "/foo/bar";
}
\f
-void _initialize_maint_cmds ();
-void
-_initialize_maint_cmds ()
+INIT_GDB_FILE (maint_cmds)
{
struct cmd_list_element *cmd;
#
# Where SOURCE-FILES is the list of source files to extract init functions from.
#
-# Formatting conventions: The name of the initialization routines must begin
-# with `_initialize_`, must start in column zero, and be followed with exactly
-# ` ()`. For example:
+
+# An initialization function is introduced using the "INIT_GDB_FILE"
+# macro. In ordinary code this expands to a function declaration (to
+# avoid a warning) and then the start of a definition. In the
+# generated init.c, though, it is expanded differently. For example:
#
-# void
-# _initialize_foo ()
+# INIT_GDB_FILE (foo)
# {
# ...
# }
echo "/* It is created automatically by the Makefile. */"
echo "#include <algorithm>"
echo ""
-sed -n -e 's/^\(void \|\)\(_initialize_[a-zA-Z0-9_]*\) ()$/\2/p' "$@" | while read -r name; do
- echo "extern initialize_file_ftype $name;"
-done
+echo "#undef INIT_GDB_FILE"
+echo "#define INIT_GDB_FILE(NAME) extern void _initialize_ ## NAME ();"
+grep -h '^[ ]*INIT_GDB_FILE\b' "$@"
echo ""
echo "void initialize_all_files ();"
echo "void"
echo "initialize_all_files ()"
echo "{"
+echo " typedef void initialize_file_ftype (void);"
+echo ""
echo " std::vector<initialize_file_ftype *> functions ="
echo " {"
-sed -n -e 's/^\(void \|\)\(_initialize_[a-zA-Z0-9_]*\) ()$/\2/p' "$@" | while read -r name; do
- echo " $name,"
-done
+echo "#undef INIT_GDB_FILE"
+echo "#define INIT_GDB_FILE(NAME) _initialize_ ## NAME,"
+grep -h '^[ ]*INIT_GDB_FILE\b' "$@"
echo " };"
echo ""
echo " /* If GDB_REVERSE_INIT_FUNCTIONS is set (any value), reverse the"
reader.install ();
}
-void _initialize_mdebugread ();
-void
-_initialize_mdebugread ()
+INIT_GDB_FILE (mdebugread)
{
mdebug_register_index
= register_symbol_register_impl (LOC_REGISTER, &mdebug_register_funcs);
static struct cmd_list_element *mem_set_cmdlist;
static struct cmd_list_element *mem_show_cmdlist;
-void _initialize_mem ();
-void
-_initialize_mem ()
+INIT_GDB_FILE (mem)
{
add_com ("mem", class_vars, mem_command, _("\
Define or reset attributes for memory regions.\n\
return gdbarch;
}
-void _initialize_mep_tdep ();
-void
-_initialize_mep_tdep ()
+INIT_GDB_FILE (mep_tdep)
{
mep_csr_reggroup = reggroup_new ("csr", USER_REGGROUP);
mep_cr_reggroup = reggroup_new ("cr", USER_REGGROUP);
current_uiout->field_string ("inferior_tty_terminal", inferior_tty);
}
-void _initialize_mi_cmd_env ();
-void
-_initialize_mi_cmd_env ()
+INIT_GDB_FILE (mi_cmd_env)
{
const char *env;
return it->second.get ();
}
-void _initialize_mi_cmds ();
-void
-_initialize_mi_cmds ()
+INIT_GDB_FILE (mi_cmds)
{
add_builtin_mi_commands ();
}
return new mi_interp (name);
}
-void _initialize_mi_interp ();
-void
-_initialize_mi_interp ()
+INIT_GDB_FILE (mi_interp)
{
/* The various interpreter levels. */
interp_factory_register (INTERP_MI2, mi_interp_factory);
return (int) num;
}
-void _initialize_mi_main ();
-void
-_initialize_mi_main ()
+INIT_GDB_FILE (mi_main)
{
set_show_commands mi_async_cmds
= add_setshow_boolean_cmd ("mi-async", class_run,
µblaze_linux_sighandler_tramp_frame);
}
-void _initialize_microblaze_linux_tdep ();
-void
-_initialize_microblaze_linux_tdep ()
+INIT_GDB_FILE (microblaze_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_microblaze, 0, GDB_OSABI_LINUX,
microblaze_linux_init_abi);
return gdbarch;
}
-void _initialize_microblaze_tdep ();
-void
-_initialize_microblaze_tdep ()
+INIT_GDB_FILE (microblaze_tdep)
{
gdbarch_register (bfd_arch_microblaze, microblaze_gdbarch_init);
}
}
-void _initialize_mips_fbsd_nat ();
-void
-_initialize_mips_fbsd_nat ()
+INIT_GDB_FILE (mips_fbsd_nat)
{
add_inf_child_target (&the_mips_fbsd_nat_target);
}
mips_fbsd_lp64_fetch_link_map_offsets));
}
-void _initialize_mips_fbsd_tdep ();
-void
-_initialize_mips_fbsd_tdep ()
+INIT_GDB_FILE (mips_fbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_mips, 0, GDB_OSABI_FREEBSD,
mips_fbsd_init_abi);
linux_nat_trad_target::close ();
}
-void _initialize_mips_linux_nat ();
-void
-_initialize_mips_linux_nat ()
+INIT_GDB_FILE (mips_linux_nat)
{
add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
&show_debug_regs, _("\
}
}
-void _initialize_mips_linux_tdep ();
-void
-_initialize_mips_linux_tdep ()
+INIT_GDB_FILE (mips_linux_tdep)
{
const struct bfd_arch_info *arch_info;
}
}
-void _initialize_mipsnbsd_nat ();
-void
-_initialize_mipsnbsd_nat ()
+INIT_GDB_FILE (mipsnbsd_nat)
{
add_inf_child_target (&the_mips_nbsd_nat_target);
}
mipsnbsd_lp64_fetch_link_map_offsets));
}
-void _initialize_mipsnbsd_tdep ();
-void
-_initialize_mipsnbsd_tdep ()
+INIT_GDB_FILE (mipsnbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_mips, 0, GDB_OSABI_NETBSD,
mipsnbsd_init_abi);
frame_base_append_sniffer (gdbarch, mips_sde_frame_base_sniffer);
}
-void _initialize_mips_sde_tdep ();
-void
-_initialize_mips_sde_tdep ()
+INIT_GDB_FILE (mips_sde_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_mips,
bfd_target_elf_flavour,
mips_fpu_type_str (mips_get_fpu_type (gdbarch)));
}
-void _initialize_mips_tdep ();
-void
-_initialize_mips_tdep ()
+INIT_GDB_FILE (mips_tdep)
{
static struct cmd_list_element *mipsfpulist = NULL;
perror_with_name (_("Couldn't write registers"));
}
-void _initialize_mips64obsd_nat ();
-void
-_initialize_mips64obsd_nat ()
+INIT_GDB_FILE (mips64obsd_nat)
{
add_inf_child_target (&the_mips64_obsd_nat_target);
}
(gdbarch, svr4_lp64_fetch_link_map_offsets);
}
-void _initialize_mips64obsd_tdep ();
-void
-_initialize_mips64obsd_tdep ()
+INIT_GDB_FILE (mips64obsd_tdep)
{
gdbarch_register_osabi (bfd_arch_mips, 0, GDB_OSABI_OPENBSD,
mips64obsd_init_abi);
NULL, /* sym_probe_fns */
};
-void _initialize_mipsread ();
-void
-_initialize_mipsread ()
+INIT_GDB_FILE (mipsread)
{
add_symtab_fns (bfd_target_ecoff_flavour, &ecoff_sym_fns);
}
tramp_frame_prepend_unwinder (gdbarch, &am33_linux_rt_sigframe);
}
-void _initialize_mn10300_linux_tdep ();
-void
-_initialize_mn10300_linux_tdep ()
+INIT_GDB_FILE (mn10300_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_mn10300, 0,
GDB_OSABI_LINUX, am33_linux_init_osabi);
tdep->am33_mode);
}
-void _initialize_mn10300_tdep ();
-void
-_initialize_mn10300_tdep ()
+INIT_GDB_FILE (mn10300_tdep)
{
gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
}
/* Register this machine's init routine. */
-void _initialize_moxie_tdep ();
-void
-_initialize_moxie_tdep ()
+INIT_GDB_FILE (moxie_tdep)
{
gdbarch_register (bfd_arch_moxie, moxie_gdbarch_init);
}
/* Register the initialization routine. */
-void _initialize_msp430_tdep ();
-void
-_initialize_msp430_tdep ()
+INIT_GDB_FILE (msp430_tdep)
{
gdbarch_register (bfd_arch_msp430, msp430_gdbarch_init);
}
return gdbarch;
}
-void _initialize_nds32_tdep ();
-void
-_initialize_nds32_tdep ()
+INIT_GDB_FILE (nds32_tdep)
{
/* Initialize gdbarch. */
gdbarch_register (bfd_arch_nds32, nds32_gdbarch_init);
return 0;
}
-void _initialize_objc_language ();
-void
-_initialize_objc_language ()
+INIT_GDB_FILE (objc_language)
{
add_info ("selectors", info_selectors_command,
_("All Objective-C selectors, or those matching REGEXP."));
gdb_printf (file, _("Observer debugging is %s.\n"), value);
}
-void _initialize_observer ();
-void
-_initialize_observer ()
+INIT_GDB_FILE (observer)
{
add_setshow_boolean_cmd ("observer", class_maintenance,
&gdb::observers::observer_debug, _("\
/* Initialize OpenRISC Linux native support. */
-void _initialize_or1k_linux_nat ();
-void
-_initialize_or1k_linux_nat ()
+INIT_GDB_FILE (or1k_linux_nat)
{
/* Register the target. */
linux_target = &the_or1k_linux_nat_target;
/* Initialize OpenRISC Linux target support. */
-void _initialize_or1k_linux_tdep ();
-void
-_initialize_or1k_linux_tdep ()
+INIT_GDB_FILE (or1k_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_or1k, 0, GDB_OSABI_LINUX,
or1k_linux_init_abi);
}
\f
-void _initialize_or1k_tdep ();
-void
-_initialize_or1k_tdep ()
+INIT_GDB_FILE (or1k_tdep)
{
/* Register this architecture. */
gdbarch_register (bfd_arch_or1k, or1k_gdbarch_init, or1k_dump_tdep);
gdbarch_osabi_name (GDB_OSABI_DEFAULT));
}
-void _initialize_gdb_osabi ();
-void
-_initialize_gdb_osabi ()
+INIT_GDB_FILE (gdb_osabi)
{
/* Register a generic sniffer for ELF flavoured files. */
gdbarch_register_osabi_sniffer (bfd_arch_unknown,
info_osdata (arg);
}
-void _initialize_osdata ();
-void
-_initialize_osdata ()
+INIT_GDB_FILE (osdata)
{
add_info ("os", info_osdata_command,
_("Show OS data ARG."));
common_val_print (val, stream, recurse, &opts, current_language);
}
-void _initialize_pascal_valprint ();
-void
-_initialize_pascal_valprint ()
+INIT_GDB_FILE (pascal_valprint)
{
add_setshow_boolean_cmd ("pascal_static-members", class_support,
&user_print_options.pascal_static_field_print, _("\
va_end (args);
}
-void _initialize_parse ();
-void
-_initialize_parse ()
+INIT_GDB_FILE (parse)
{
add_setshow_zuinteger_cmd ("expression", class_maintenance,
&expressiondebug,
return 1;
}
-void _initialize_ppcfbsd_nat ();
-void
-_initialize_ppcfbsd_nat ()
+INIT_GDB_FILE (ppcfbsd_nat)
{
add_inf_child_target (&the_ppc_fbsd_nat_target);
ppcfbsd_get_thread_local_address);
}
-void _initialize_ppcfbsd_tdep ();
-void
-_initialize_ppcfbsd_tdep ()
+INIT_GDB_FILE (ppcfbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_powerpc, bfd_mach_ppc, GDB_OSABI_FREEBSD,
ppcfbsd_init_abi);
return lwp_arch_private_info (lp);
}
-void _initialize_ppc_linux_nat ();
-void
-_initialize_ppc_linux_nat ()
+INIT_GDB_FILE (ppc_linux_nat)
{
linux_target = &the_ppc_linux_nat_target;
}
-void _initialize_ppc_linux_tdep ();
-void
-_initialize_ppc_linux_tdep ()
+INIT_GDB_FILE (ppc_linux_tdep)
{
/* Register for all sub-families of the POWER/PowerPC: 32-bit and
64-bit PowerPC, and the older rs6k. */
return 1;
}
-void _initialize_ppcnbsd_nat ();
-void
-_initialize_ppcnbsd_nat ()
+INIT_GDB_FILE (ppcnbsd_nat)
{
/* Support debugging kernel virtual memory images. */
bsd_kvm_add_target (ppcnbsd_supply_pcb);
tramp_frame_prepend_unwinder (gdbarch, &ppcnbsd2_sigtramp);
}
-void _initialize_ppcnbsd_tdep ();
-void
-_initialize_ppcnbsd_tdep ()
+INIT_GDB_FILE (ppcnbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_NETBSD,
ppcnbsd_init_abi);
return 1;
}
-void _initialize_ppcobsd_nat ();
-void
-_initialize_ppcobsd_nat ()
+INIT_GDB_FILE (ppcobsd_nat)
{
add_inf_child_target (&the_ppc_obsd_nat_target);
frame_unwind_append_unwinder (gdbarch, &ppcobsd_sigtramp_frame_unwind);
}
-void _initialize_ppcobsd_tdep ();
-void
-_initialize_ppcobsd_tdep ()
+INIT_GDB_FILE (ppcobsd_tdep)
{
gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_OPENBSD,
ppcobsd_init_abi);
}
}
-void _initialize_printcmd ();
-void
-_initialize_printcmd ()
+INIT_GDB_FILE (printcmd)
{
struct cmd_list_element *c;
std::vector<const static_probe_ops *> all_static_probe_ops;
-void _initialize_probe ();
-void
-_initialize_probe ()
+INIT_GDB_FILE (probe)
{
all_static_probe_ops.push_back (&any_static_probe_ops);
}
}
-void _initialize_proc_api ();
-void
-_initialize_proc_api ()
+INIT_GDB_FILE (proc_api)
{
add_setshow_boolean_cmd ("procfs-trace", no_class, &procfs_trace, _("\
Set tracing for /proc api calls."), _("\
{
}
-void _initialize_proc_events ();
-void
-_initialize_proc_events ()
+INIT_GDB_FILE (proc_events)
{
init_syscall_table ();
}
return ph->thread->ptid.pid ();
}
-void _initialize_proc_service ();
-void
-_initialize_proc_service ()
+INIT_GDB_FILE (proc_service)
{
/* This function solely exists to make sure this module is linked
into the final binary. */
proc_trace_syscalls (args, from_tty, PR_SYSEXIT, FLAG_RESET);
}
-void _initialize_procfs ();
-void
-_initialize_procfs ()
+INIT_GDB_FILE (procfs)
{
add_com ("proc-trace-entry", no_class, proc_trace_sysentry_cmd,
_("Give a trace of entries into the syscall."));
}
#endif
-void _initialize_producer ();
-void
-_initialize_producer ()
+INIT_GDB_FILE (producer)
{
#if defined GDB_SELF_TEST
selftests::register_test
}
}
-void _initialize_psymtab ();
-void
-_initialize_psymtab ()
+INIT_GDB_FILE (psymtab)
{
add_cmd ("psymbols", class_maintenance, maintenance_print_psymbols, _("\
Print dump of current partial symbol definitions.\n\
0, /* tp_alloc */
};
-void _initialize_py_breakpoint ();
-void
-_initialize_py_breakpoint ()
+INIT_GDB_FILE (py_breakpoint)
{
add_setshow_boolean_cmd
("py-breakpoint", class_maintenance, &pybp_debug,
/* Global initialization for this file. */
-void _initialize_py_connection ();
-void
-_initialize_py_connection ()
+INIT_GDB_FILE (py_connection)
{
gdb::observers::connection_removed.attach (connpy_connection_removed,
"py-connection");
call_dap_fn ("pre_command_loop");
}
-void _initialize_py_interp ();
-void
-_initialize_py_interp ()
+INIT_GDB_FILE (py_interp)
{
/* The dap code uses module typing, available starting python 3.5. */
#if PY_VERSION_HEX >= 0x03050000
0, /* tp_alloc */
};
-void _initialize_py_micmd ();
-void
-_initialize_py_micmd ()
+INIT_GDB_FILE (py_micmd)
{
add_setshow_boolean_cmd
("py-micmd", class_maintenance, &pymicmd_debug,
return 0;
}
-void _initialize_py_unwind ();
-void
-_initialize_py_unwind ()
+INIT_GDB_FILE (py_unwind)
{
add_setshow_boolean_cmd
("py-unwind", class_maintenance, &pyuw_debug,
/* See python.h. */
cmd_list_element *python_cmd_element = nullptr;
-void _initialize_python ();
-void
-_initialize_python ()
+INIT_GDB_FILE (python)
{
cmd_list_element *python_interactive_cmd
= add_com ("python-interactive", class_obscure,
/* Module startup initialization function, automagically called by
init.c. */
-void _initialize_ravenscar ();
-void
-_initialize_ravenscar ()
+INIT_GDB_FILE (ravenscar)
{
/* Notice when the inferior is created in order to push the
ravenscar ops if needed. */
/* Initialize btrace commands. */
-void _initialize_record_btrace ();
-void
-_initialize_record_btrace ()
+INIT_GDB_FILE (record_btrace)
{
cmd_list_element *record_btrace_cmd
= add_prefix_cmd ("btrace", class_obscure, cmd_record_btrace_start,
}
}
-void _initialize_record_full ();
-void
-_initialize_record_full ()
+INIT_GDB_FILE (record_full)
{
struct cmd_list_element *c;
&record_call_history_size);
}
-void _initialize_record ();
-void
-_initialize_record ()
+INIT_GDB_FILE (record)
{
struct cmd_list_element *c;
"maintenance print remote-registers");
}
-void _initialize_regcache_dump ();
-void
-_initialize_regcache_dump ()
+INIT_GDB_FILE (regcache_dump)
{
add_cmd ("registers", class_maintenance, maintenance_print_registers,
_("Print the internal register configuration.\n"
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
-void _initialize_regcache ();
-void
-_initialize_regcache ()
+INIT_GDB_FILE (regcache)
{
struct cmd_list_element *c;
const reggroup *const save_reggroup = &save_group;
const reggroup *const restore_reggroup = &restore_group;
-void _initialize_reggroup ();
-void
-_initialize_reggroup ()
+INIT_GDB_FILE (reggroup)
{
add_cmd ("reggroups", class_maintenance,
maintenance_print_reggroups, _("\
delete_async_event_handler (&get_pending_events_token);
}
-void _initialize_notif ();
-void
-_initialize_notif ()
+INIT_GDB_FILE (notif)
{
add_setshow_boolean_cmd ("notification", no_class, ¬if_debug,
_("\
return result;
}
-void _initialize_remote_sim ();
-void
-_initialize_remote_sim ()
+INIT_GDB_FILE (remote_sim)
{
struct cmd_list_element *c;
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
-void _initialize_remote ();
-void
-_initialize_remote ()
+INIT_GDB_FILE (remote)
{
add_target (remote_target_info, remote_target::open);
add_target (extended_remote_target_info, extended_remote_target::open);
}
}
-void _initialize_reverse ();
-void
-_initialize_reverse ()
+INIT_GDB_FILE (reverse)
{
cmd_list_element *reverse_step_cmd
= add_com ("reverse-step", class_run, reverse_step, _("\
PT_SETFPREGS, &riscv_fbsd_fpregset);
}
-void _initialize_riscv_fbsd_nat ();
-void
-_initialize_riscv_fbsd_nat ()
+INIT_GDB_FILE (riscv_fbsd_nat)
{
add_inf_child_target (&the_riscv_fbsd_nat_target);
}
riscv_fbsd_get_thread_local_address);
}
-void _initialize_riscv_fbsd_tdep ();
-void
-_initialize_riscv_fbsd_tdep ()
+INIT_GDB_FILE (riscv_fbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_riscv, 0, GDB_OSABI_FREEBSD,
riscv_fbsd_init_abi);
/* Initialize RISC-V Linux native support. */
-void _initialize_riscv_linux_nat ();
-void
-_initialize_riscv_linux_nat ()
+INIT_GDB_FILE (riscv_linux_nat)
{
/* Register the target. */
linux_target = &the_riscv_linux_nat_target;
/* Initialize RISC-V Linux target support. */
-void _initialize_riscv_linux_tdep ();
-void
-_initialize_riscv_linux_tdep ()
+INIT_GDB_FILE (riscv_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_riscv, 0, GDB_OSABI_LINUX,
riscv_linux_init_abi);
/* Initialize RISC-V bare-metal target support. */
-void _initialize_riscv_none_tdep ();
-void
-_initialize_riscv_none_tdep ()
+INIT_GDB_FILE (riscv_none_tdep)
{
gdbarch_register_osabi (bfd_arch_riscv, 0, GDB_OSABI_NONE,
riscv_none_init_abi);
}
}
-void _initialize_riscv_tdep ();
-void
-_initialize_riscv_tdep ()
+INIT_GDB_FILE (riscv_tdep)
{
riscv_init_reggroups ();
/* Register the above initialization routine. */
-void _initialize_rl78_tdep ();
-void
-_initialize_rl78_tdep ()
+INIT_GDB_FILE (rl78_tdep)
{
gdbarch_register (bfd_arch_rl78, rl78_gdbarch_init);
}
}
}
-void _initialize_rs6000_nat ();
-void
-_initialize_rs6000_nat ()
+INIT_GDB_FILE (rs6000_nat)
{
add_inf_child_target (&the_rs6000_nat_target);
}
frame_unwind_append_unwinder (gdbarch, &aix_sighandle_frame_unwind);
}
-void _initialize_rs6000_aix_tdep ();
-void
-_initialize_rs6000_aix_tdep ()
+INIT_GDB_FILE (rs6000_aix_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
bfd_target_xcoff_flavour,
set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
}
-void _initialize_rs6000_lynx178_tdep ();
-void
-_initialize_rs6000_lynx178_tdep ()
+INIT_GDB_FILE (rs6000_lynx178_tdep)
{
gdbarch_register_osabi_sniffer (bfd_arch_rs6000,
bfd_target_xcoff_flavour,
/* Initialization code. */
-void _initialize_rs6000_tdep ();
-void
-_initialize_rs6000_tdep ()
+INIT_GDB_FILE (rs6000_tdep)
{
gdbarch_register (bfd_arch_rs6000, rs6000_gdbarch_init, rs6000_dump_tdep);
gdbarch_register (bfd_arch_powerpc, rs6000_gdbarch_init, rs6000_dump_tdep);
#endif
}
-void _initialize_run_on_main_thread ();
-void
-_initialize_run_on_main_thread ()
+INIT_GDB_FILE (run_on_main_thread)
{
#if CXX_STD_THREAD
/* The variable main_thread_id should be initialized when entering main, or
\f
-void _initialize_rust_exp ();
-void
-_initialize_rust_exp ()
+INIT_GDB_FILE (rust_exp)
{
int code = regcomp (&number_regex, number_regex_text, REG_EXTENDED);
/* If the regular expression was incorrect, it was a programming
/* Register the above initialization routine. */
-void _initialize_rx_tdep ();
-void
-_initialize_rx_tdep ()
+INIT_GDB_FILE (rx_tdep)
{
gdbarch_register (bfd_arch_rx, rx_gdbarch_init);
initialize_tdesc_rx ();
return gdbarch;
}
-void _initialize_s12z_tdep ();
-void
-_initialize_s12z_tdep ()
+INIT_GDB_FILE (s12z_tdep)
{
gdbarch_register (bfd_arch_s12z, s12z_gdbarch_init, NULL);
}
tdesc_s390_linux32);
}
-void _initialize_s390_nat ();
-void
-_initialize_s390_nat ()
+INIT_GDB_FILE (s390_nat)
{
/* Register the target. */
linux_target = &the_s390_linux_nat_target;
set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_S390X);
}
-void _initialize_s390_linux_tdep ();
-void
-_initialize_s390_linux_tdep ()
+INIT_GDB_FILE (s390_linux_tdep)
{
/* Hook us into the OSABI mechanism. */
gdbarch_register_osabi (bfd_arch_s390, bfd_mach_s390_31, GDB_OSABI_LINUX,
#endif /* GDB_SELF_TEST */
-void _initialize_s390_tdep ();
-void
-_initialize_s390_tdep ()
+INIT_GDB_FILE (s390_tdep)
{
/* Hook us into the gdbarch mechanism. */
gdbarch_register (bfd_arch_s390, s390_gdbarch_init);
#endif
}
-void _initialize_ser_dos ();
-void
-_initialize_ser_dos ()
+INIT_GDB_FILE (ser_dos)
{
serial_add_interface (&dos_ops);
net_windows_done_wait_handle
};
-void _initialize_ser_windows ();
-void
-_initialize_ser_windows ()
+INIT_GDB_FILE (ser_windows)
{
WSADATA wsa_data;
ser_unix_write_prim
};
-void _initialize_ser_pipe ();
-void
-_initialize_ser_pipe ()
+INIT_GDB_FILE (ser_pipe)
{
serial_add_interface (&pipe_ops);
}
#endif /* USE_WIN32API */
-void _initialize_ser_tcp ();
-void
-_initialize_ser_tcp ()
+INIT_GDB_FILE (ser_tcp)
{
#ifdef USE_WIN32API
/* Do nothing; the TCP serial operations will be initialized in
uds_write_prim
};
-void _initialize_ser_socket ();
-void
-_initialize_ser_socket ()
+INIT_GDB_FILE (ser_socket)
{
serial_add_interface (&uds_ops);
}
ser_unix_write_prim
};
-void _initialize_ser_hardwire ();
-void
-_initialize_ser_hardwire ()
+INIT_GDB_FILE (ser_hardwire)
{
serial_add_interface (&hardwire_ops);
serial_parity = GDBPARITY_NONE;
}
-void _initialize_serial ();
-void
-_initialize_serial ()
+INIT_GDB_FILE (serial)
{
#if 0
add_com ("connect", class_obscure, connect_command, _("\
tramp_frame_prepend_unwinder (gdbarch, &sh_linux_rt_sigreturn_tramp_frame);
}
-void _initialize_sh_linux_tdep ();
-void
-_initialize_sh_linux_tdep ()
+INIT_GDB_FILE (sh_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_sh, 0, GDB_OSABI_LINUX, sh_linux_init_abi);
}
}
}
-void _initialize_shnbsd_nat ();
-void
-_initialize_shnbsd_nat ()
+INIT_GDB_FILE (shnbsd_nat)
{
add_inf_child_target (&the_sh_nbsd_nat_target);
}
(gdbarch, svr4_ilp32_fetch_link_map_offsets);
}
-void _initialize_shnbsd_tdep ();
-void
-_initialize_shnbsd_tdep ()
+INIT_GDB_FILE (shnbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_sh, 0, GDB_OSABI_NETBSD,
shnbsd_init_abi);
return gdbarch;
}
-void _initialize_sh_tdep ();
-void
-_initialize_sh_tdep ()
+INIT_GDB_FILE (sh_tdep)
{
gdbarch_register (bfd_arch_sh, sh_gdbarch_init, NULL);
}
}
-void _initialize_step_skip ();
-void
-_initialize_step_skip ()
+INIT_GDB_FILE (step_skip)
{
static struct cmd_list_element *skiplist = NULL;
struct cmd_list_element *c;
return (thread_info->ptid);
}
-void _initialize_sol_thread ();
-void
-_initialize_sol_thread ()
+INIT_GDB_FILE (sol_thread)
{
void *dlhandle;
default_find_solib_addr,
};
-void _initialize_solib_aix ();
-void
-_initialize_solib_aix ()
+INIT_GDB_FILE (solib_aix)
{
gdb::observers::normal_stop.attach (solib_aix_normal_stop_observer,
"solib-aix");
default_find_solib_addr,
};
-void _initialize_dsbt_solib ();
-void
-_initialize_dsbt_solib ()
+INIT_GDB_FILE (dsbt_solib)
{
/* Debug this file's internals. */
add_setshow_zuinteger_cmd ("solib-dsbt", class_maintenance,
solib_add (nullptr, 0, auto_solib_add);
}
-/* -Wmissing-prototypes */
-extern initialize_file_ftype _initialize_rocm_solib;
-
void
-_initialize_rocm_solib ()
+INIT_GDB_FILE (rocm_solib)
{
/* The dependency on the amd-dbgapi exists because solib-rocm's
inferior_created observer needs amd-dbgapi to have attached the process,
svr4_get_solibs_in_ns,
};
-void _initialize_svr4_solib ();
-void
-_initialize_svr4_solib ()
+INIT_GDB_FILE (svr4_solib)
{
gdb::observers::free_objfile.attach (svr4_free_objfile_observer,
"solib-svr4");
nullptr,
};
-void _initialize_solib ();
-
-void
-_initialize_solib ()
+INIT_GDB_FILE (solib)
{
gdb::observers::free_objfile.attach (remove_user_added_objfile, "solib");
gdb::observers::inferior_execd.attach (
}
#endif
-void _initialize_source_cache ();
-void
-_initialize_source_cache ()
+INIT_GDB_FILE (source_cache)
{
add_cmd ("source-cache", class_maintenance, source_cache_flush_command,
_("Force gdb to flush its source code cache."),
}
\f
-void _initialize_source ();
-void
-_initialize_source ()
+INIT_GDB_FILE (source)
{
init_source_path ();
sparc32_collect_fpregset (sparc_fpregmap, regcache, regnum, fpregs);
}
-void _initialize_sparc_linux_nat ();
-void
-_initialize_sparc_linux_nat ()
+INIT_GDB_FILE (sparc_linux_nat)
{
sparc_fpregmap = &sparc32_bsd_fpregmap;
sparc32_linux_gdb_signal_to_target);
}
-void _initialize_sparc_linux_tdep ();
-void
-_initialize_sparc_linux_tdep ()
+INIT_GDB_FILE (sparc_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_LINUX,
sparc32_linux_init_abi);
}
\f
-void _initialize_sparc_nat ();
-void
-_initialize_sparc_nat ()
+INIT_GDB_FILE (sparc_nat)
{
/* Default to using SunOS 4 register sets. */
if (sparc_gregmap == NULL)
static sparc_target<inf_ptrace_target> the_sparc_nbsd_nat_target;
-void _initialize_sparcnbsd_nat ();
-void
-_initialize_sparcnbsd_nat ()
+INIT_GDB_FILE (sparcnbsd_nat)
{
sparc_gregmap = &sparc32nbsd_gregmap;
sparc_fpregmap = &sparc32_bsd_fpregmap;
(gdbarch, svr4_ilp32_fetch_link_map_offsets);
}
-void _initialize_sparcnbsd_tdep ();
-void
-_initialize_sparcnbsd_tdep ()
+INIT_GDB_FILE (sparcnbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_NETBSD,
sparc32nbsd_init_abi);
bsd_uthread_set_collect_uthread (gdbarch, sparc32obsd_collect_uthread);
}
-void _initialize_sparc32obsd_tdep ();
-void
-_initialize_sparc32obsd_tdep ()
+INIT_GDB_FILE (sparc32obsd_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_OPENBSD,
sparc32obsd_init_abi);
frame_unwind_append_unwinder (gdbarch, &sparc32_sol2_sigtramp_frame_unwind);
}
-void _initialize_sparc_sol2_tdep ();
-void
-_initialize_sparc_sol2_tdep ()
+INIT_GDB_FILE (sparc_sol2_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, 0,
GDB_OSABI_SOLARIS, sparc32_sol2_init_abi);
32 * 4, /* %fsr */
};
-void _initialize_sparc_tdep ();
-void
-_initialize_sparc_tdep ()
+INIT_GDB_FILE (sparc_tdep)
{
gdbarch_register (bfd_arch_sparc, sparc32_gdbarch_init);
}
/* Add some extra features to the generic SPARC target. */
static sparc_target<fbsd_nat_target> the_sparc64_fbsd_nat_target;
-void _initialize_sparc64fbsd_nat ();
-void
-_initialize_sparc64fbsd_nat ()
+INIT_GDB_FILE (sparc64fbsd_nat)
{
add_inf_child_target (&the_sparc64_fbsd_nat_target);
(gdbarch, svr4_lp64_fetch_link_map_offsets);
}
-void _initialize_sparc64fbsd_tdep ();
-void
-_initialize_sparc64fbsd_tdep ()
+INIT_GDB_FILE (sparc64fbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
GDB_OSABI_FREEBSD, sparc64fbsd_init_abi);
sparc64_collect_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
}
-void _initialize_sparc64_linux_nat ();
-void
-_initialize_sparc64_linux_nat ()
+INIT_GDB_FILE (sparc64_linux_nat)
{
sparc_fpregmap = &sparc64_bsd_fpregmap;
set_gdbarch_report_signal_info (gdbarch, sparc64_linux_report_signal_info);
}
-void _initialize_sparc64_linux_tdep ();
-void
-_initialize_sparc64_linux_tdep ()
+INIT_GDB_FILE (sparc64_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
GDB_OSABI_LINUX, sparc64_linux_init_abi);
return 0;
}
-void _initialize_sparc64_nat ();
-void
-_initialize_sparc64_nat ()
+INIT_GDB_FILE (sparc64_nat)
{
sparc_supply_gregset = sparc64_supply_gregset;
sparc_collect_gregset = sparc64_collect_gregset;
/* We've got nothing to add to the generic SPARC target. */
static sparc_target<inf_ptrace_target> the_sparc64_nbsd_nat_target;
-void _initialize_sparc64nbsd_nat ();
-void
-_initialize_sparc64nbsd_nat ()
+INIT_GDB_FILE (sparc64nbsd_nat)
{
sparc_supply_gregset = sparc64nbsd_supply_gregset;
sparc_collect_gregset = sparc64nbsd_collect_gregset;
(gdbarch, svr4_lp64_fetch_link_map_offsets);
}
-void _initialize_sparc64nbsd_tdep ();
-void
-_initialize_sparc64nbsd_tdep ()
+INIT_GDB_FILE (sparc64nbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
GDB_OSABI_NETBSD, sparc64nbsd_init_abi);
/* Add some extra features to the generic SPARC target. */
static sparc_target<obsd_nat_target> the_sparc64_obsd_nat_target;
-void _initialize_sparc64obsd_nat ();
-void
-_initialize_sparc64obsd_nat ()
+INIT_GDB_FILE (sparc64obsd_nat)
{
sparc_supply_gregset = sparc64_supply_gregset;
sparc_collect_gregset = sparc64_collect_gregset;
bsd_uthread_set_collect_uthread (gdbarch, sparc64obsd_collect_uthread);
}
-void _initialize_sparc64obsd_tdep ();
-void
-_initialize_sparc64obsd_tdep ()
+INIT_GDB_FILE (sparc64obsd_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
GDB_OSABI_OPENBSD, sparc64obsd_init_abi);
set_gdbarch_software_single_step (gdbarch, NULL);
}
-void _initialize_sparc64_sol2_tdep ();
-void
-_initialize_sparc64_sol2_tdep ()
+INIT_GDB_FILE (sparc64_sol2_tdep)
{
gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
GDB_OSABI_SOLARIS, sparc64_sol2_init_abi);
do_assign (next_address, cnt, version);
}
-void _initialize_sparc64_adi_tdep ();
-void
-_initialize_sparc64_adi_tdep ()
+INIT_GDB_FILE (sparc64_adi_tdep)
{
add_basic_prefix_cmd ("adi", class_support,
_("ADI version related commands."),
/* Initializer for this module. */
-void _initialize_stabsread ();
-void
-_initialize_stabsread ()
+INIT_GDB_FILE (stabsread)
{
undef_types_allocated = 20;
undef_types_length = 0;
/* Commands with a prefix of `info frame'. */
static struct cmd_list_element *info_frame_cmd_list = NULL;
-void _initialize_stack ();
-void
-_initialize_stack ()
+INIT_GDB_FILE (stack)
{
struct cmd_list_element *cmd;
info_probes_for_spops (arg, from_tty, &stap_static_probe_ops);
}
-void _initialize_stap_probe ();
-void
-_initialize_stap_probe ()
+INIT_GDB_FILE (stap_probe)
{
all_static_probe_ops.push_back (&stap_static_probe_ops);
error (_("Standard register ``$ps'' is not available for this target"));
}
-void _initialize_frame_reg ();
-void
-_initialize_frame_reg ()
+INIT_GDB_FILE (frame_reg)
{
/* Frame based $fp, $pc, $sp and $ps. These only come into play
when the target does not define its own version of these
gdbarch_data->get_tls_dtp_offset = get_tls_dtp_offset;
}
-void _initialize_svr4_tls_tdep ();
-void
-_initialize_svr4_tls_tdep ()
+INIT_GDB_FILE (svr4_tls_tdep)
{
add_setshow_boolean_cmd ("force-internal-tls-address-lookup", class_obscure,
&force_internal_tls_address_lookup, _("\
gdb_printf (file, _("Symfile debugging is %s.\n"), value);
}
-void _initialize_symfile_debug ();
-void
-_initialize_symfile_debug ()
+INIT_GDB_FILE (symfile_debug)
{
add_setshow_boolean_cmd ("symfile", no_class, &debug_symfile, _("\
Set debugging of the symfile functions."), _("\
}
}
-void _initialize_symfile_mem ();
-void
-_initialize_symfile_mem ()
+INIT_GDB_FILE (symfile_mem)
{
add_cmd ("add-symbol-file-from-memory", class_files,
add_symbol_file_from_memory_command,
#endif /* GDB_SELF_TEST */
-void _initialize_symfile ();
-void
-_initialize_symfile ()
+INIT_GDB_FILE (symfile)
{
struct cmd_list_element *c;
/* Do early runtime initializations. */
-void _initialize_symmisc ();
-void
-_initialize_symmisc ()
+INIT_GDB_FILE (symmisc)
{
add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
Print dump of current symbol definitions.\n\
\f
-void _initialize_symtab ();
-void
-_initialize_symtab ()
+INIT_GDB_FILE (symtab)
{
cmd_list_element *c;
print_connection (current_uiout, args);
}
-void _initialize_target_connection ();
-
-void
-_initialize_target_connection ()
+INIT_GDB_FILE (target_connection)
{
add_info ("connections", info_connections_command,
_("\
gdb_printf (_("The dcache was flushed.\n"));
}
-void _initialize_target_dcache ();
-void
-_initialize_target_dcache ()
+INIT_GDB_FILE (target_dcache)
{
add_setshow_boolean_cmd ("stack-cache", class_support,
&stack_cache_enabled_1, _("\
(long) selftests::xml_tdesc.size (), failed);
}
-void _initialize_target_descriptions ();
-void
-_initialize_target_descriptions ()
+INIT_GDB_FILE (target_descriptions)
{
cmd_list_element *cmd;
update_observer_mode ();
}
-void _initialize_target ();
-
-void
-_initialize_target ()
+INIT_GDB_FILE (target)
{
the_debug_target = new debug_target ();
NULL,
};
-void _initialize_thread ();
-void
-_initialize_thread ()
+INIT_GDB_FILE (thread)
{
static struct cmd_list_element *thread_apply_list = NULL;
cmd_list_element *c;
&tic6x_linux_rt_sigreturn_tramp_frame);
}
-void _initialize_tic6x_linux_tdep ();
-void
-_initialize_tic6x_linux_tdep ()
+INIT_GDB_FILE (tic6x_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_tic6x, 0, GDB_OSABI_LINUX,
tic6x_uclinux_init_abi);
return gdbarch;
}
-void _initialize_tic6x_tdep ();
-void
-_initialize_tic6x_tdep ()
+INIT_GDB_FILE (tic6x_tdep)
{
gdbarch_register (bfd_arch_tic6x, tic6x_gdbarch_init);
}
perror_with_name (_("Couldn't write registers"));
}
-void _initialize_tile_linux_nat ();
-void
-_initialize_tile_linux_nat ()
+INIT_GDB_FILE (tile_linux_nat)
{
linux_target = &the_tilegx_linux_nat_target;
add_inf_child_target (&the_tilegx_linux_nat_target);
set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
}
-void _initialize_tilegx_linux_tdep ();
-void
-_initialize_tilegx_linux_tdep ()
+INIT_GDB_FILE (tilegx_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_tilegx, bfd_mach_tilegx, GDB_OSABI_LINUX,
tilegx_linux_init_abi);
return gdbarch;
}
-void _initialize_tilegx_tdep ();
-void
-_initialize_tilegx_tdep ()
+INIT_GDB_FILE (tilegx_tdep)
{
gdbarch_register (bfd_arch_tilegx, tilegx_gdbarch_init);
}
init_colorsupport_var ();
}
-void _initialize_top ();
-void
-_initialize_top ()
+INIT_GDB_FILE (top)
{
/* Determine a default value for the history filename. */
const char *tmpenv = getenv ("GDBHISTFILE");
/* module initialization */
-void _initialize_ctf ();
-void
-_initialize_ctf ()
+INIT_GDB_FILE (ctf)
{
#if HAVE_LIBBABELTRACE
add_target (ctf_target_info, ctf_target_open,
trace_tdesc += "\n";
}
-void _initialize_tracefile_tfile ();
-void
-_initialize_tracefile_tfile ()
+INIT_GDB_FILE (tracefile_tfile)
{
add_target (tfile_target_info, tfile_target_open,
filename_maybe_quoted_completer);
return -1;
}
-void _initialize_tracefile ();
-void
-_initialize_tracefile ()
+INIT_GDB_FILE (tracefile)
{
add_com ("tsave", class_trace, tsave_command, _("\
Save the trace data to a file.\n\
cmd_list_element *while_stepping_cmd_element = nullptr;
/* module initialization */
-void _initialize_tracepoint ();
-void
-_initialize_tracepoint ()
+INIT_GDB_FILE (tracepoint)
{
struct cmd_list_element *c;
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
-void _initialize_tui_disasm ();
-void
-_initialize_tui_disasm ()
+INIT_GDB_FILE (tui_disasm)
{
#if GDB_SELF_TEST
selftests::register_test ("tui-disasm", selftests::tui::disasm::run_tests);
tui_attach_detach_observers (false);
}
-void _initialize_tui_hooks ();
-void
-_initialize_tui_hooks ()
+INIT_GDB_FILE (tui_hooks)
{
/* Install the permanent hooks. */
gdb::observers::new_objfile.attach (tui_new_objfile_hook, "tui-hooks");
return new tui_interp (name);
}
-void _initialize_tui_interp ();
-void
-_initialize_tui_interp ()
+INIT_GDB_FILE (tui_interp)
{
interp_factory_register (INTERP_TUI, tui_interp_factory);
/* Function to initialize gdb commands, for tui window layout
manipulation. */
-void _initialize_tui_layout ();
-void
-_initialize_tui_layout ()
+INIT_GDB_FILE (tui_layout)
{
struct cmd_list_element *layout_cmd
= add_basic_prefix_cmd ("layout", class_tui, _("\
complete_on_enum (tracker, extra, text, word);
}
-void _initialize_tui_regs ();
-void
-_initialize_tui_regs ()
+INIT_GDB_FILE (tui_regs)
{
struct cmd_list_element **tuicmd, *cmd;
/* Function to initialize gdb commands, for tui window stack
manipulation. */
-void _initialize_tui_stack ();
-void
-_initialize_tui_stack ()
+INIT_GDB_FILE (tui_stack)
{
add_com ("update", class_tui, tui_update_command,
_("\
/* Function to initialize gdb commands, for tui window
manipulation. */
-void _initialize_tui_win ();
-void
-_initialize_tui_win ()
+INIT_GDB_FILE (tui_win)
{
static struct cmd_list_element *tui_setlist;
static struct cmd_list_element *tui_showlist;
return true;
}
-void _initialize_tui ();
-void
-_initialize_tui ()
+INIT_GDB_FILE (tui)
{
struct cmd_list_element **tuicmd;
value);
}
-void _initialize_typeprint ();
-void
-_initialize_typeprint ()
+INIT_GDB_FILE (typeprint)
{
struct cmd_list_element *c;
gdb_printf ("New UI allocated\n");
}
-void _initialize_ui ();
-void
-_initialize_ui ()
+INIT_GDB_FILE (ui)
{
cmd_list_element *c = add_cmd ("new-ui", class_support, new_ui_command, _("\
Create a new UI.\n\
} /* namespace array_view_tests */
} /* namespace selftests */
-void _initialize_array_view_selftests ();
-void
-_initialize_array_view_selftests ()
+INIT_GDB_FILE (array_view_selftests)
{
selftests::register_test ("array_view",
selftests::array_view_tests::run_tests);
}
}
-void _initialize_child_path_selftests ();
-void
-_initialize_child_path_selftests ()
+INIT_GDB_FILE (child_path_selftests)
{
selftests::register_test ("child_path",
selftests::child_path::test);
}
}
-void _initialize_cli_utils_selftests ();
-void
-_initialize_cli_utils_selftests ()
+INIT_GDB_FILE (cli_utils_selftests)
{
selftests::register_test ("cli_utils",
selftests::cli_utils::test_cli_utils);
} /* namespace selftests */
-void _initialize_command_def_selftests ();
-void
-_initialize_command_def_selftests ()
+INIT_GDB_FILE (command_def_selftests)
{
selftests::register_test
("help_doc_invariants",
} /* namespace selftests */
-void _initialize_common_utils_selftests ();
-void
-_initialize_common_utils_selftests ()
+INIT_GDB_FILE (common_utils_selftests)
{
selftests::register_test ("string_printf", selftests::string_printf_tests);
selftests::register_test ("string_vprintf", selftests::string_vprintf_tests);
} /* namespace selftests */
-void _initialize_copy_bitwise_utils_selftests ();
-void
-_initialize_copy_bitwise_utils_selftests ()
+INIT_GDB_FILE (copy_bitwise_utils_selftests)
{
selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests);
}
} /* namespace enum_flags_tests */
} /* namespace selftests */
-void _initialize_enum_flags_selftests ();
-
-void
-_initialize_enum_flags_selftests ()
+INIT_GDB_FILE (enum_flags_selftests)
{
selftests::register_test ("enum-flags",
selftests::enum_flags_tests::self_test);
} /* namespace gdb_environ */
} /* namespace selftests */
-void _initialize_environ_selftests ();
-void
-_initialize_environ_selftests ()
+INIT_GDB_FILE (environ_selftests)
{
selftests::register_test ("gdb_environ",
selftests::gdb_environ_tests::run_tests);
} /* namespace selftests */
-void _initialize_filtered_iterator_selftests ();
-void
-_initialize_filtered_iterator_selftests ()
+INIT_GDB_FILE (filtered_iterator_selftests)
{
selftests::register_test ("filtered_iterator",
selftests::test_filtered_iterator);
} /* namespace format_pieces */
} /* namespace selftests */
-void _initialize_format_pieces_selftests ();
-void
-_initialize_format_pieces_selftests ()
+INIT_GDB_FILE (format_pieces_selftests)
{
selftests::register_test ("format_pieces",
selftests::format_pieces::run_tests);
} /* namespace selftests */
-void _initialize_frame_info_ptr_selftests ();
-void
-_initialize_frame_info_ptr_selftests ()
+INIT_GDB_FILE (frame_info_ptr_selftests)
{
selftests::register_test ("frame_info_ptr_user",
selftests::test_user_created_frame);
} /* namespace function_view */
} /* namespace selftests */
-void _initialize_function_view_selftests ();
-void
-_initialize_function_view_selftests ()
+INIT_GDB_FILE (function_view_selftests)
{
selftests::register_test ("function_view",
selftests::function_view::run_tests);
} /* namespace gdb_tilde_expand_tests */
} /* namespace selftests */
-void _initialize_gdb_tilde_expand_selftests ();
-void
-_initialize_gdb_tilde_expand_selftests ()
+INIT_GDB_FILE (gdb_tilde_expand_selftests)
{
selftests::register_test
("gdb_tilde_expand", selftests::gdb_tilde_expand_tests::do_test);
}
-void _initialize_gmp_utils_selftests ();
-
-void
-_initialize_gmp_utils_selftests ()
+INIT_GDB_FILE (gmp_utils_selftests)
{
selftests::register_test ("gdb_mpz_as_integer",
selftests::gdb_mpz_as_integer);
test_node_is_linked ();
}
-void _initialize_intrusive_list_selftests ();
-
-void
-_initialize_intrusive_list_selftests ()
+INIT_GDB_FILE (intrusive_list_selftests)
{
selftests::register_test ("intrusive_list", test_intrusive_list);
}
}} /* namespace selftests::lookup_name */
-void _initialize_lookup_name_info_selftests ();
-void
-_initialize_lookup_name_info_selftests ()
+INIT_GDB_FILE (lookup_name_info_selftests)
{
selftests::register_test ("lookup_name_info",
selftests::lookup_name::run_tests);
}
}
-void _initialize_main_thread_selftests ();
-void
-_initialize_main_thread_selftests ()
+INIT_GDB_FILE (main_thread_selftests)
{
#if CXX_STD_THREAD
selftests::register_test ("run_on_main_thread",
#endif /* HAVE_LIBEXPAT */
-void _initialize_memory_map_selftests ();
-void
-_initialize_memory_map_selftests ()
+INIT_GDB_FILE (memory_map_selftests)
{
#if defined(HAVE_LIBEXPAT)
selftests::register_test
} /* namespace memrange_tests */
} /* namespace selftests */
-void _initialize_memrange_selftests ();
-void
-_initialize_memrange_selftests ()
+INIT_GDB_FILE (memrange_selftests)
{
selftests::register_test
("normalize_mem_ranges",
}
}
-void _initialize_mkdir_recursive_selftests ();
-void
-_initialize_mkdir_recursive_selftests ()
+INIT_GDB_FILE (mkdir_recursive_selftests)
{
selftests::register_test ("mkdir_recursive",
selftests::mkdir_recursive::test);
} /* namespace observers */
} /* namespace selftests */
-void _initialize_observer_selftest ();
-void
-_initialize_observer_selftest ()
+INIT_GDB_FILE (observer_selftest)
{
selftests::register_test ("gdb::observers",
selftests::observers::run_tests);
} /* namespace offset_type */
} /* namespace selftests */
-void _initialize_offset_type_selftests ();
-void
-_initialize_offset_type_selftests ()
+INIT_GDB_FILE (offset_type_selftests)
{
selftests::register_test ("offset_type", selftests::offset_type::run_tests);
}
} /* namespace packed_tests */
} /* namespace selftests */
-void _initialize_packed_selftests ();
-void
-_initialize_packed_selftests ()
+INIT_GDB_FILE (packed_selftests)
{
selftests::register_test ("packed", selftests::packed_tests::run_tests);
}
#endif /* CXX_STD_THREAD */
-void _initialize_parallel_for_selftests ();
-void
-_initialize_parallel_for_selftests ()
+INIT_GDB_FILE (parallel_for_selftests)
{
#ifdef CXX_STD_THREAD
selftests::register_test ("parallel_for",
} /* namespace parse_connection_spec_tests */
} /* namespace selftests */
-void _initialize_parse_connection_spec_selftests ();
-void
-_initialize_parse_connection_spec_selftests ()
+INIT_GDB_FILE (parse_connection_spec_selftests)
{
selftests::register_test ("parse_connection_spec",
selftests::parse_connection_spec_tests::run_tests);
}
}
-void _initialize_path_join_selftests ();
-void
-_initialize_path_join_selftests ()
+INIT_GDB_FILE (path_join_selftests)
{
selftests::register_test ("path_join",
selftests::path_join::test);
} /* namespace remote_args_tests */
} /* namespace selftests */
-void _initialize_remote_arg_selftests ();
-
-void
-_initialize_remote_arg_selftests ()
+INIT_GDB_FILE (remote_arg_selftests)
{
selftests::register_test ("remote-args",
selftests::remote_args_tests::self_test);
} /* namespace rsp_low */
} /* namespace selftests */
-void _initialize_rsp_low_selftests ();
-void
-_initialize_rsp_low_selftests ()
+INIT_GDB_FILE (rsp_low_selftests)
{
selftests::register_test ("hex2bin_byte_vector",
selftests::rsp_low::test_hex2bin_byte_vector);
} /* namespace scoped_fd */
} /* namespace selftests */
-void _initialize_scoped_fd_selftests ();
-void
-_initialize_scoped_fd_selftests ()
+INIT_GDB_FILE (scoped_fd_selftests)
{
selftests::register_test ("scoped_fd",
selftests::scoped_fd::run_tests);
} /* namespace scoped_ignore_sig */
} /* namespace selftests */
-void _initialize_scoped_ignore_signal_selftests ();
-void
-_initialize_scoped_ignore_signal_selftests ()
+INIT_GDB_FILE (scoped_ignore_signal_selftests)
{
#ifdef SIGPIPE
selftests::register_test ("scoped_ignore_sigpipe",
#endif /* !defined(HAVE_SYS_MMAN_H) */
-void _initialize_scoped_mmap_selftests ();
-void
-_initialize_scoped_mmap_selftests ()
+INIT_GDB_FILE (scoped_mmap_selftests)
{
#if defined(HAVE_SYS_MMAN_H)
selftests::register_test ("scoped_mmap",
} /* namespace scoped_restore_tests */
} /* namespace selftests */
-void _initialize_scoped_restore_selftests ();
-void
-_initialize_scoped_restore_selftests ()
+INIT_GDB_FILE (scoped_restore_selftests)
{
selftests::register_test ("scoped_restore",
selftests::scoped_restore_tests::run_tests);
} /* namespace selftests */
-void _initialize_search_memory_selftests ();
-void
-_initialize_search_memory_selftests ()
+INIT_GDB_FILE (search_memory_selftests)
{
selftests::register_test ("search_memory",
selftests::search_memory_tests::run_tests);
} /* namespace style */
} /* namespace selftests */
-void _initialize_style_selftest ();
-void
-_initialize_style_selftest ()
+INIT_GDB_FILE (style_selftest)
{
selftests::register_test ("style",
selftests::style::run_tests);
} /* namespace tracepoint_tests */
} /* namespace selftests */
-void _initialize_tracepoint_selftests ();
-void
-_initialize_tracepoint_selftests ()
+INIT_GDB_FILE (tracepoint_selftests)
{
selftests::register_test
("parse_static_tracepoint_marker_definition",
#endif /* TUI */
-void _initialize_tui_selftest ();
-void
-_initialize_tui_selftest ()
+INIT_GDB_FILE (tui_selftest)
{
#ifdef TUI
selftests::register_test ("tui", selftests::tui::run_tests);
} /* namespace file*/
} /* namespace selftests */
-void _initialize_ui_file_selftest ();
-void
-_initialize_ui_file_selftest ()
+INIT_GDB_FILE (ui_file_selftest)
{
selftests::register_test ("ui-file",
selftests::file::run_tests);
}
}
-void _initialize_unique_xmalloc_ptr_char ();
-void
-_initialize_unique_xmalloc_ptr_char ()
+INIT_GDB_FILE (unique_xmalloc_ptr_char)
{
selftests::register_test ("unique_xmalloc_ptr_char",
selftests::unpack::unique_xmalloc_ptr_char);
}
}
-void _initialize_unpack_selftests ();
-void
-_initialize_unpack_selftests ()
+INIT_GDB_FILE (unpack_selftests)
{
selftests::register_test_foreach_arch
("unpack_field_as_long", selftests::unpack::unpack_field_as_long_tests);
} /* namespace vector_utils_tests */
} /* namespace selftests */
-void _initialize_vec_utils_selftests ();
-void
-_initialize_vec_utils_selftests ()
+INIT_GDB_FILE (vec_utils_selftests)
{
selftests::register_test
("unordered_remove",
}
}
-void _initialize_xml_utils ();
-void
-_initialize_xml_utils ()
+INIT_GDB_FILE (xml_utils)
{
selftests::register_test ("xml_escape_text",
selftests::xml_utils::test_xml_escape_text);
}
}
-void _initialize_user_regs ();
-void
-_initialize_user_regs ()
+INIT_GDB_FILE (user_regs)
{
add_cmd ("user-registers", class_maintenance,
maintenance_print_user_registers,
}
#endif
-void _initialize_utils ();
-void
-_initialize_utils ()
+INIT_GDB_FILE (utils)
{
add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
Set number of characters where GDB should wrap lines of its output."), _("\
return gdbarch;
}
-void _initialize_v850_tdep ();
-void
-_initialize_v850_tdep ()
+INIT_GDB_FILE (v850_tdep)
{
gdbarch_register (bfd_arch_v850, v850_gdbarch_init);
gdbarch_register (bfd_arch_v850_rh850, v850_gdbarch_init);
error (_("cannot cast non-number to complex"));
}
-void _initialize_valops ();
-void
-_initialize_valops ()
+INIT_GDB_FILE (valops)
{
add_setshow_boolean_cmd ("overload-resolution", class_support,
&overload_resolution, _("\
#endif
-void _initialize_valprint ();
-void
-_initialize_valprint ()
+INIT_GDB_FILE (valprint)
{
#if GDB_SELF_TEST
selftests::register_test_foreach_arch ("print-flags", test_print_flags);
} /* namespace selftests */
#endif /* GDB_SELF_TEST */
-void _initialize_values ();
-void
-_initialize_values ()
+INIT_GDB_FILE (values)
{
cmd_list_element *show_convenience_cmd
= add_cmd ("convenience", no_class, show_convenience, _("\
return obj->obj_name == name;
}
-void _initialize_varobj ();
-void
-_initialize_varobj ()
+INIT_GDB_FILE (varobj)
{
varobj_table = htab_create_alloc (5, hash_varobj, eq_varobj_and_string,
nullptr, xcalloc, xfree);
return 1;
}
-void _initialize_vaxbsd_nat ();
-void
-_initialize_vaxbsd_nat ()
+INIT_GDB_FILE (vaxbsd_nat)
{
add_inf_child_target (&the_vax_bsd_nat_target);
(gdbarch, svr4_ilp32_fetch_link_map_offsets);
}
-void _initialize_vaxnbsd_tdep ();
-void
-_initialize_vaxnbsd_tdep ()
+INIT_GDB_FILE (vaxnbsd_tdep)
{
gdbarch_register_osabi (bfd_arch_vax, 0, GDB_OSABI_NETBSD,
vaxnbsd_elf_init_abi);
return (gdbarch);
}
-void _initialize_vax_tdep ();
-void
-_initialize_vax_tdep ()
+INIT_GDB_FILE (vax_tdep)
{
gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
}
}
-void _initialize_windows_nat ();
-void
-_initialize_windows_nat ()
+INIT_GDB_FILE (windows_nat)
{
x86_dr_low.set_control = cygwin_set_dr7;
x86_dr_low.set_addr = cygwin_set_dr;
return WaitForSingleObject (th->h, 0) != WAIT_OBJECT_0;
}
-void _initialize_check_for_gdb_ini ();
-void
-_initialize_check_for_gdb_ini ()
+INIT_GDB_FILE (check_for_gdb_ini)
{
char *homedir;
if (inhibit_gdbinit)
return normal_pid_to_str (ptid);
}
-void _initialize_windows_tdep ();
-void
-_initialize_windows_tdep ()
+INIT_GDB_FILE (windows_tdep)
{
init_w32_command_list ();
cmd_list_element *info_w32_thread_information_block_cmd
#endif /* PT_GETDBREGS */
-void _initialize_x86_bsd_nat ();
-void
-_initialize_x86_bsd_nat ()
+INIT_GDB_FILE (x86_bsd_nat)
{
#ifdef HAVE_PT_GETDBREGS
x86_dr_low.set_control = x86bsd_dr_set_control;
}
#endif /* i386_DEBUG_STATE */
-void _initialize_x86_gnu_nat ();
-void
-_initialize_x86_gnu_nat ()
+INIT_GDB_FILE (x86_gnu_nat)
{
#ifdef i386_DEBUG_STATE
x86_dr_low.set_control = x86_gnu_dr_set_control;
}
\f
-void _initialize_x86_linux_nat ();
-void
-_initialize_x86_linux_nat ()
+INIT_GDB_FILE (x86_linux_nat)
{
/* Initialize the debug register function vectors. */
x86_dr_low.set_control = x86_linux_dr_set_control;
return l_nimpid - 1;
}
-void _initialize_xcoffread ();
-void
-_initialize_xcoffread ()
+INIT_GDB_FILE (xcoffread)
{
add_symtab_fns (bfd_target_xcoff_flavour, &xcoff_sym_fns);
}
return text;
}
-void _initialize_xml_support ();
-void _initialize_xml_support ();
-void
-_initialize_xml_support ()
+INIT_GDB_FILE (xml_support)
{
add_setshow_boolean_cmd ("xml", class_maintenance, &debug_xml,
_("Set XML parser debugging."),
Initializer function for the Sanyo Xstormy16a module.
Called by gdb at start-up. */
-void _initialize_xstormy16_tdep ();
-void
-_initialize_xstormy16_tdep ()
+INIT_GDB_FILE (xstormy16_tdep)
{
gdbarch_register (bfd_arch_xstormy16, xstormy16_gdbarch_init);
}
return PS_OK;
}
-void _initialize_xtensa_linux_nat ();
-void
-_initialize_xtensa_linux_nat ()
+INIT_GDB_FILE (xtensa_linux_nat)
{
const xtensa_regtable_t *ptr;
svr4_fetch_objfile_link_map);
}
-void _initialize_xtensa_linux_tdep ();
-void
-_initialize_xtensa_linux_tdep ()
+INIT_GDB_FILE (xtensa_linux_tdep)
{
gdbarch_register_osabi (bfd_arch_xtensa, bfd_mach_xtensa, GDB_OSABI_LINUX,
xtensa_linux_init_abi);
error (_("xtensa_dump_tdep(): not implemented"));
}
-void _initialize_xtensa_tdep ();
-void
-_initialize_xtensa_tdep ()
+INIT_GDB_FILE (xtensa_tdep)
{
gdbarch_register (bfd_arch_xtensa, xtensa_gdbarch_init, xtensa_dump_tdep);
xtensa_init_reggroups ();
while (1);
}
-extern initialize_file_ftype _initialize_z80_tdep;
-
-void
-_initialize_z80_tdep ()
+INIT_GDB_FILE (z80_tdep)
{
gdbarch_register (bfd_arch_z80, z80_gdbarch_init);
initialize_tdesc_z80 ();
projects / thirdparty / binutils-gdb.git / commitdiff
