/* This file was created with the aid of ``gdbarch.sh''.
- The bourn shell script ``gdbarch.sh'' creates the files
+ The Bourne shell script ``gdbarch.sh'' creates the files
``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
against the existing ``gdbarch.[hc]''. Any differences found
being reported.
If editing this file, please also run gdbarch.sh and merge any
- changes into that script. Conversely, when makeing sweeping changes
+ changes into that script. Conversely, when making sweeping changes
to this file, modifying gdbarch.sh and using its output may prove
easier. */
verify_gdbarch(): Confirm that the target updated the field
correctly.
- gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
+ gdbarch_dump(): Add a fprintf_unfiltered call so that the new
field is dumped out
``startup_gdbarch()'': Append an initial value to the static
int double_bit;
int long_double_bit;
int ptr_bit;
+ int addr_bit;
int bfd_vma_bit;
int ieee_float;
gdbarch_read_pc_ftype *read_pc;
const struct floatformat * float_format;
const struct floatformat * double_format;
const struct floatformat * long_double_format;
+ gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
};
8 * sizeof (long double),
8 * sizeof (void*),
8 * sizeof (void*),
+ 8 * sizeof (void*),
0,
0,
0,
0,
0,
0,
+ 0,
/* startup_gdbarch() */
};
gdbarch->long_double_bit = 2*TARGET_DOUBLE_BIT;
gdbarch->ptr_bit = TARGET_INT_BIT;
gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
+ gdbarch->read_pc = generic_target_read_pc;
+ gdbarch->write_pc = generic_target_write_pc;
+ gdbarch->read_fp = generic_target_read_fp;
+ gdbarch->write_fp = generic_target_write_fp;
+ gdbarch->read_sp = generic_target_read_sp;
+ gdbarch->write_sp = generic_target_write_sp;
gdbarch->num_regs = -1;
gdbarch->sp_regnum = -1;
gdbarch->fp_regnum = -1;
gdbarch->frame_args_skip = -1;
gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
gdbarch->extra_stack_alignment_needed = 1;
+ gdbarch->convert_from_func_ptr_addr = default_convert_from_func_ptr_addr;
/* gdbarch_alloc() */
return gdbarch;
/* Skip verify of double_bit, invalid_p == 0 */
/* Skip verify of long_double_bit, invalid_p == 0 */
/* Skip verify of ptr_bit, invalid_p == 0 */
+ if (gdbarch->addr_bit == 0)
+ gdbarch->addr_bit = TARGET_PTR_BIT;
/* Skip verify of bfd_vma_bit, invalid_p == 0 */
/* Skip verify of ieee_float, invalid_p == 0 */
- if ((GDB_MULTI_ARCH >= 1)
- && (gdbarch->read_pc == 0))
- internal_error ("gdbarch: verify_gdbarch: read_pc invalid");
- if ((GDB_MULTI_ARCH >= 1)
- && (gdbarch->write_pc == 0))
- internal_error ("gdbarch: verify_gdbarch: write_pc invalid");
- if ((GDB_MULTI_ARCH >= 1)
- && (gdbarch->read_fp == 0))
- internal_error ("gdbarch: verify_gdbarch: read_fp invalid");
- if ((GDB_MULTI_ARCH >= 1)
- && (gdbarch->write_fp == 0))
- internal_error ("gdbarch: verify_gdbarch: write_fp invalid");
- if ((GDB_MULTI_ARCH >= 1)
- && (gdbarch->read_sp == 0))
- internal_error ("gdbarch: verify_gdbarch: read_sp invalid");
- if ((GDB_MULTI_ARCH >= 1)
- && (gdbarch->write_sp == 0))
- internal_error ("gdbarch: verify_gdbarch: write_sp invalid");
+ /* Skip verify of read_pc, invalid_p == 0 */
+ /* Skip verify of write_pc, invalid_p == 0 */
+ /* Skip verify of read_fp, invalid_p == 0 */
+ /* Skip verify of write_fp, invalid_p == 0 */
+ /* Skip verify of read_sp, invalid_p == 0 */
+ /* Skip verify of write_sp, invalid_p == 0 */
if ((GDB_MULTI_ARCH >= 2)
&& (gdbarch->num_regs == -1))
internal_error ("gdbarch: verify_gdbarch: num_regs invalid");
gdbarch->double_format = default_double_format (gdbarch);
if (gdbarch->long_double_format == 0)
gdbarch->long_double_format = &floatformat_unknown;
+ /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
}
"gdbarch_dump: TARGET_PTR_BIT # %s\n",
XSTRING (TARGET_PTR_BIT));
#endif
+#ifdef TARGET_ADDR_BIT
+ fprintf_unfiltered (file,
+ "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
+ XSTRING (TARGET_ADDR_BIT));
+#endif
#ifdef TARGET_BFD_VMA_BIT
fprintf_unfiltered (file,
"gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
"gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
XSTRING (TARGET_LONG_DOUBLE_FORMAT));
#endif
+#ifdef CONVERT_FROM_FUNC_PTR_ADDR
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
+ XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr)));
+#endif
#ifdef TARGET_ARCHITECTURE
if (TARGET_ARCHITECTURE != NULL)
fprintf_unfiltered (file,
"gdbarch_dump: TARGET_PTR_BIT = %ld\n",
(long) TARGET_PTR_BIT);
#endif
+#ifdef TARGET_ADDR_BIT
+ fprintf_unfiltered (file,
+ "gdbarch_dump: TARGET_ADDR_BIT = %ld\n",
+ (long) TARGET_ADDR_BIT);
+#endif
#ifdef TARGET_BFD_VMA_BIT
fprintf_unfiltered (file,
"gdbarch_dump: TARGET_BFD_VMA_BIT = %ld\n",
fprintf_unfiltered (file,
"gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %ld\n",
(long) TARGET_LONG_DOUBLE_FORMAT);
+#endif
+#ifdef CONVERT_FROM_FUNC_PTR_ADDR
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = 0x%08lx\n",
+ (long) current_gdbarch->convert_from_func_ptr_addr
+ /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
#endif
if (current_gdbarch->dump_tdep != NULL)
current_gdbarch->dump_tdep (current_gdbarch, file);
gdbarch->ptr_bit = ptr_bit;
}
+int
+gdbarch_addr_bit (struct gdbarch *gdbarch)
+{
+ if (gdbarch->addr_bit == 0)
+ internal_error ("gdbarch: gdbarch_addr_bit invalid");
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
+ return gdbarch->addr_bit;
+}
+
+void
+set_gdbarch_addr_bit (struct gdbarch *gdbarch,
+ int addr_bit)
+{
+ gdbarch->addr_bit = addr_bit;
+}
+
int
gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
{
gdbarch->long_double_format = long_double_format;
}
+CORE_ADDR
+gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+ if (gdbarch->convert_from_func_ptr_addr == 0)
+ internal_error ("gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
+ if (gdbarch_debug >= 2)
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
+ return gdbarch->convert_from_func_ptr_addr (addr);
+}
+
+void
+set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
+ gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
+{
+ gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
+}
+
-/* Keep a registrary of per-architecture data-pointers required by GDB
+/* Keep a registry of per-architecture data-pointers required by GDB
modules. */
struct gdbarch_data
struct gdbarch_data_registration *next;
};
-struct gdbarch_data_registrary
+struct gdbarch_data_registry
{
int nr;
struct gdbarch_data_registration *registrations;
};
-struct gdbarch_data_registrary gdbarch_data_registrary =
+struct gdbarch_data_registry gdbarch_data_registry =
{
0, NULL,
};
register_gdbarch_data (gdbarch_data_ftype *init)
{
struct gdbarch_data_registration **curr;
- for (curr = &gdbarch_data_registrary.registrations;
+ for (curr = &gdbarch_data_registry.registrations;
(*curr) != NULL;
curr = &(*curr)->next);
(*curr) = XMALLOC (struct gdbarch_data_registration);
(*curr)->next = NULL;
(*curr)->init = init;
(*curr)->data = XMALLOC (struct gdbarch_data);
- (*curr)->data->index = gdbarch_data_registrary.nr++;
+ (*curr)->data->index = gdbarch_data_registry.nr++;
return (*curr)->data;
}
init_gdbarch_data (struct gdbarch *gdbarch)
{
struct gdbarch_data_registration *rego;
- gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
+ gdbarch->nr_data = gdbarch_data_registry.nr + 1;
gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
- for (rego = gdbarch_data_registrary.registrations;
+ for (rego = gdbarch_data_registry.registrations;
rego != NULL;
rego = rego->next)
{
-/* Keep a registrary of swaped data required by GDB modules. */
+/* Keep a registry of swapped data required by GDB modules. */
struct gdbarch_swap
{
struct gdbarch_swap_registration *next;
};
-struct gdbarch_swap_registrary
+struct gdbarch_swap_registry
{
int nr;
struct gdbarch_swap_registration *registrations;
};
-struct gdbarch_swap_registrary gdbarch_swap_registrary =
+struct gdbarch_swap_registry gdbarch_swap_registry =
{
0, NULL,
};
gdbarch_swap_ftype *init)
{
struct gdbarch_swap_registration **rego;
- for (rego = &gdbarch_swap_registrary.registrations;
+ for (rego = &gdbarch_swap_registry.registrations;
(*rego) != NULL;
rego = &(*rego)->next);
(*rego) = XMALLOC (struct gdbarch_swap_registration);
{
struct gdbarch_swap_registration *rego;
struct gdbarch_swap **curr = &gdbarch->swap;
- for (rego = gdbarch_swap_registrary.registrations;
+ for (rego = gdbarch_swap_registry.registrations;
rego != NULL;
rego = rego->next)
{
}
-/* Keep a registrary of the architectures known by GDB. */
+/* Keep a registry of the architectures known by GDB. */
struct gdbarch_registration
{
struct gdbarch_registration *next;
};
-static struct gdbarch_registration *gdbarch_registrary = NULL;
+static struct gdbarch_registration *gdbarch_registry = NULL;
static void
append_name (const char ***buf, int *nr, const char *name)
int nr_arches = 0;
const char **arches = NULL;
struct gdbarch_registration *rego;
- for (rego = gdbarch_registrary;
+ for (rego = gdbarch_registry;
rego != NULL;
rego = rego->next)
{
{
struct gdbarch_registration **curr;
const struct bfd_arch_info *bfd_arch_info;
- /* Check that BFD reconizes this architecture */
+ /* Check that BFD recognizes this architecture */
bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
if (bfd_arch_info == NULL)
{
internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
}
/* Check that we haven't seen this architecture before */
- for (curr = &gdbarch_registrary;
+ for (curr = &gdbarch_registry;
(*curr) != NULL;
curr = &(*curr)->next)
{
(*curr)->dump_tdep = dump_tdep;
(*curr)->arches = NULL;
(*curr)->next = NULL;
- /* When non- multi-arch, install what ever target dump routine we've
- been provided - hopefully that routine has been writen correct
+ /* When non- multi-arch, install whatever target dump routine we've
+ been provided - hopefully that routine has been written correctly
and works regardless of multi-arch. */
if (!GDB_MULTI_ARCH && dump_tdep != NULL
&& startup_gdbarch.dump_tdep == NULL)
/* A default for abfd? */
/* Find the target that knows about this architecture. */
- for (rego = gdbarch_registrary;
+ for (rego = gdbarch_registry;
rego != NULL;
rego = rego->next)
if (rego->bfd_architecture == info.bfd_architecture)