# Make certain that the script is not running in an internationalized
# environment.
-LANG=c ; export LANG
-LC_ALL=c ; export LC_ALL
+LANG=C ; export LANG
+LC_ALL=C ; export LC_ALL
compare_new ()
M:CORE_ADDR:skip_main_prologue:CORE_ADDR ip:ip
f:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs:0:0
m:const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:
+# Return the adjusted address and kind to use for Z0/Z1 packets.
+# KIND is usually the memory length of the breakpoint, but may have a
+# different target-specific meaning.
+m:void:remote_breakpoint_from_pc:CORE_ADDR *pcptr, int *kindptr:pcptr, kindptr:0:default_remote_breakpoint_from_pc::0
M:CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr
m:int:memory_insert_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_insert_breakpoint::0
m:int:memory_remove_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_remove_breakpoint::0
# see the comments in infrun.c.
m:CORE_ADDR:displaced_step_location:void:::NULL::(! gdbarch->displaced_step_location) != (! gdbarch->displaced_step_copy_insn)
+# Relocate an instruction to execute at a different address. OLDLOC
+# is the address in the inferior memory where the instruction to
+# relocate is currently at. On input, TO points to the destination
+# where we want the instruction to be copied (and possibly adjusted)
+# to. On output, it points to one past the end of the resulting
+# instruction(s). The effect of executing the instruction at TO shall
+# be the same as if executing it at FROM. For example, call
+# instructions that implicitly push the return address on the stack
+# should be adjusted to return to the instruction after OLDLOC;
+# relative branches, and other PC-relative instructions need the
+# offset adjusted; etc.
+M:void:relocate_instruction:CORE_ADDR *to, CORE_ADDR from:to, from::NULL
+
# Refresh overlay mapped state for section OSECT.
F:void:overlay_update:struct obj_section *osect:osect
# True if inferiors share an address space (e.g., uClinux).
m:int:has_shared_address_space:void:::default_has_shared_address_space::0
+
+# True if a fast tracepoint can be set at an address.
+m:int:fast_tracepoint_valid_at:CORE_ADDR addr, int *isize, char **msg:addr, isize, msg::default_fast_tracepoint_valid_at::0
+
+# Return the "auto" target charset.
+f:const char *:auto_charset:void::default_auto_charset:default_auto_charset::0
+# Return the "auto" target wide charset.
+f:const char *:auto_wide_charset:void::default_auto_wide_charset:default_auto_wide_charset::0
+
+# If non-empty, this is a file extension that will be opened in place
+# of the file extension reported by the shared library list.
+#
+# This is most useful for toolchains that use a post-linker tool,
+# where the names of the files run on the target differ in extension
+# compared to the names of the files GDB should load for debug info.
+v:const char *:solib_symbols_extension:::::::pstring (gdbarch->solib_symbols_extension)
+
+# If true, the target OS has DOS-based file system semantics. That
+# is, absolute paths include a drive name, and the backslash is
+# considered a directory separator.
+v:int:has_dos_based_file_system:::0:0::0
EOF
}
return format[0]->name;
}
+static const char *
+pstring (const char *string)
+{
+ if (string == NULL)
+ return "(null)";
+ return string;
+}
+
EOF
# gdbarch open the gdbarch object
gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
{
void *data = obstack_alloc (arch->obstack, size);
+
memset (data, 0, size);
return data;
}
gdbarch_free (struct gdbarch *arch)
{
struct obstack *obstack;
+
gdb_assert (arch != NULL);
gdb_assert (!arch->initialized_p);
obstack = arch->obstack;
struct cleanup *cleanups;
long length;
char *buf;
+
log = mem_fileopen ();
cleanups = make_cleanup_ui_file_delete (log);
/* fundamental */
gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
{
const char *gdb_nm_file = "<not-defined>";
+
#if defined (GDB_NM_FILE)
gdb_nm_file = GDB_NM_FILE;
#endif
gdbarch_data_post_init_ftype *post_init)
{
struct gdbarch_data_registration **curr;
- /* Append the new registraration. */
+
+ /* Append the new registration. */
for (curr = &gdbarch_data_registry.registrations;
(*curr) != NULL;
curr = &(*curr)->next);
{
/* Accumulate a list of names based on the registed list of
architectures. */
- enum bfd_architecture a;
int nr_arches = 0;
const char **arches = NULL;
struct gdbarch_registration *rego;
+
for (rego = gdbarch_registry;
rego != NULL;
rego = rego->next)
{
struct gdbarch_registration **curr;
const struct bfd_arch_info *bfd_arch_info;
+
/* Check that BFD recognizes this architecture */
bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
if (bfd_arch_info == NULL)
void
_initialize_gdbarch (void)
{
- struct cmd_list_element *c;
-
add_setshow_zinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\\
Set architecture debugging."), _("\\
Show architecture debugging."), _("\\
projects / binutils-gdb.git / blobdiff