mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-23 18:14:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

* gdbarch.sh (target_gdbarch): Remove macro.

Browse Source 
(get_target_gdbarch): Rename to target_gdbarch.
	* gdbarch.c, gdbarch.h: Rebuild.
	* ada-tasks.c, aix-thread.c, amd64-linux-nat.c, arch-utils.c,
	arm-tdep.c, auxv.c, breakpoint.c, bsd-uthread.c, corefile.c,
	darwin-nat-info.c, dcache.c, dsrec.c, exec.c, fbsd-nat.c,
	filesystem.c, gcore.c, gnu-nat.c, i386-darwin-nat.c, i386-nat.c,
	ia64-vms-tdep.c, inf-ptrace.c, infcmd.c, jit.c, linux-nat.c,
	linux-tdep.c, linux-thread-db.c, m32r-rom.c, memattr.c,
	mep-tdep.c, microblaze-tdep.c, mips-linux-nat.c,
	mips-linux-tdep.c, mips-tdep.c, monitor.c, moxie-tdep.c,
	nto-procfs.c, nto-tdep.c, ppc-linux-nat.c, proc-service.c,
	procfs.c, progspace.c, ravenscar-thread.c, record.c,
	remote-m32r-sdi.c, remote-mips.c, remote-sim.c, remote.c,
	rl78-tdep.c, rs6000-nat.c, rx-tdep.c, s390-nat.c, sol-thread.c,
	solib-darwin.c, solib-dsbt.c, solib-frv.c, solib-ia64-hpux.c,
	solib-irix.c, solib-pa64.c, solib-som.c, solib-spu.c,
	solib-sunos.c, solib-svr4.c, solib.c, spu-linux-nat.c,
	spu-multiarch.c, spu-tdep.c, symfile-mem.c, symfile.c, symtab.c,
	target-descriptions.c, target.c, target.h, tracepoint.c,
	windows-nat.c, windows-tdep.c, xcoffsolib.c, cli/cli-dump.c,
	common/agent.c, mi/mi-interp.c, python/py-finishbreakpoint.c,
	python/py-inferior.c, python/python.c: Update.
This commit is contained in:
Tom Tromey 2012-11-09 19:58:03 +00:00
parent 0420f52b94
commit f5656eadf4
86 changed files with 410 additions and 386 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
gdb/ChangeLog
View File

@ -1,3 +1,29 @@
2012-11-09 Tom Tromey <tromey@redhat.com>
* gdbarch.sh (target_gdbarch): Remove macro.
(get_target_gdbarch): Rename to target_gdbarch.
* gdbarch.c, gdbarch.h: Rebuild.
* ada-tasks.c, aix-thread.c, amd64-linux-nat.c, arch-utils.c,
arm-tdep.c, auxv.c, breakpoint.c, bsd-uthread.c, corefile.c,
darwin-nat-info.c, dcache.c, dsrec.c, exec.c, fbsd-nat.c,
filesystem.c, gcore.c, gnu-nat.c, i386-darwin-nat.c, i386-nat.c,
ia64-vms-tdep.c, inf-ptrace.c, infcmd.c, jit.c, linux-nat.c,
linux-tdep.c, linux-thread-db.c, m32r-rom.c, memattr.c,
mep-tdep.c, microblaze-tdep.c, mips-linux-nat.c,
mips-linux-tdep.c, mips-tdep.c, monitor.c, moxie-tdep.c,
nto-procfs.c, nto-tdep.c, ppc-linux-nat.c, proc-service.c,
procfs.c, progspace.c, ravenscar-thread.c, record.c,
remote-m32r-sdi.c, remote-mips.c, remote-sim.c, remote.c,
rl78-tdep.c, rs6000-nat.c, rx-tdep.c, s390-nat.c, sol-thread.c,
solib-darwin.c, solib-dsbt.c, solib-frv.c, solib-ia64-hpux.c,
solib-irix.c, solib-pa64.c, solib-som.c, solib-spu.c,
solib-sunos.c, solib-svr4.c, solib.c, spu-linux-nat.c,
spu-multiarch.c, spu-tdep.c, symfile-mem.c, symfile.c, symtab.c,
target-descriptions.c, target.c, target.h, tracepoint.c,
windows-nat.c, windows-tdep.c, xcoffsolib.c, cli/cli-dump.c,
common/agent.c, mi/mi-interp.c, python/py-finishbreakpoint.c,
python/py-inferior.c, python/python.c: Update.
2012-11-09 Andrew Burgess <aburgess@broadcom.com>
* source.c (print_source_lines_base): Add fullname field giving

6
gdb/ada-tasks.c
View File

@ -893,7 +893,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
contains debug information on the task type (due to implicit with of
Ada.Tasking). */
data->known_tasks_element =
builtin_type (target_gdbarch)->builtin_data_ptr;
builtin_type (target_gdbarch ())->builtin_data_ptr;
data->known_tasks_length = MAX_NUMBER_OF_KNOWN_TASKS;
return;
}
@ -924,7 +924,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
/* Fallback to default values. */
data->known_tasks_element =
builtin_type (target_gdbarch)->builtin_data_ptr;
builtin_type (target_gdbarch ())->builtin_data_ptr;
data->known_tasks_length = 1;
return;
}
@ -1173,7 +1173,7 @@ info_task (struct ui_out *uiout, char *taskno_str, struct inferior *inf)
/* Print the Ada task ID. */
printf_filtered (_("Ada Task: %s\n"),
paddress (target_gdbarch, task_info->task_id));
paddress (target_gdbarch (), task_info->task_id));
/* Print the name of the task. */
if (task_info->name[0] != '\0')

4
gdb/aix-thread.c
View File

@ -887,7 +887,7 @@ pd_enable (void)
return;
/* Check application word size. */
arch64 = register_size (target_gdbarch, 0) == 8;
arch64 = register_size (target_gdbarch (), 0) == 8;
/* Check whether the application is pthreaded. */
stub_name = NULL;
@ -901,7 +901,7 @@ pd_enable (void)
if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL)))
return;
pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms);
if (!create_thread_event_breakpoint (target_gdbarch, pd_brk_addr))
if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
return;
/* Prepare for thread debugging. */

2
gdb/amd64-linux-nat.c
View File

@ -443,7 +443,7 @@ ps_err_e
ps_get_thread_area (const struct ps_prochandle *ph,
lwpid_t lwpid, int idx, void **base)
{
if (gdbarch_bfd_arch_info (target_gdbarch)->bits_per_word == 32)
if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32)
{
/* The full structure is found in <asm-i386/ldt.h>. The second
integer is the LDT's base_address and that is used to locate

4
gdb/arch-utils.c
View File

@ -506,7 +506,7 @@ gdbarch_update_p (struct gdbarch_info info)
/* If it is the same old architecture, accept the request (but don't
swap anything). */
if (new_gdbarch == target_gdbarch)
if (new_gdbarch == target_gdbarch ())
{
if (gdbarch_debug)
fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
@ -757,7 +757,7 @@ get_current_arch (void)
if (has_stack_frames ())
return get_frame_arch (get_selected_frame (NULL));
else
return target_gdbarch;
return target_gdbarch ();
}
int

12
gdb/arm-tdep.c
View File

@ -9195,7 +9195,7 @@ arm_update_current_architecture (void)
struct gdbarch_info info;
/* If the current architecture is not ARM, we have nothing to do. */
if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_arm)
if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_arm)
return;
/* Update the architecture. */
@ -9229,10 +9229,10 @@ static void
show_fp_model (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
if (arm_fp_model == ARM_FLOAT_AUTO
&& gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_arm)
&& gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_arm)
fprintf_filtered (file, _("\
The current ARM floating point model is \"auto\" (currently \"%s\").\n"),
fp_model_strings[tdep->fp_model]);
@ -9266,10 +9266,10 @@ static void
arm_show_abi (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
if (arm_abi_global == ARM_ABI_AUTO
&& gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_arm)
&& gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_arm)
fprintf_filtered (file, _("\
The current ARM ABI is \"auto\" (currently \"%s\").\n"),
arm_abi_strings[tdep->arm_abi]);
@ -9292,7 +9292,7 @@ static void
arm_show_force_mode (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
fprintf_filtered (file,
_("The current execution mode assumed "

12
gdb/auxv.c
View File

@ -76,7 +76,7 @@ ld_so_xfer_auxv (gdb_byte *readbuf,
{
struct minimal_symbol *msym;
CORE_ADDR data_address, pointer_address;
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
size_t ptr_size = TYPE_LENGTH (ptr_type);
size_t auxv_pair_size = 2 * ptr_size;
gdb_byte *ptr_buf = alloca (ptr_size);
@ -240,9 +240,9 @@ static int
default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch)
const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
/ TARGET_CHAR_BIT;
const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte *ptr = *readptr;
if (endptr == ptr)
@ -479,7 +479,7 @@ fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
fprintf_filtered (file, "%s\n", plongest (val));
break;
case hex:
fprintf_filtered (file, "%s\n", paddress (target_gdbarch, val));
fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
break;
case str:
{
@ -487,8 +487,8 @@ fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
get_user_print_options (&opts);
if (opts.addressprint)
fprintf_filtered (file, "%s ", paddress (target_gdbarch, val));
val_print_string (builtin_type (target_gdbarch)->builtin_char,
fprintf_filtered (file, "%s ", paddress (target_gdbarch (), val));
val_print_string (builtin_type (target_gdbarch ())->builtin_char,
NULL, val, -1, file, &opts);
fprintf_filtered (file, "\n");
}

14
gdb/breakpoint.c
View File

@ -2792,7 +2792,7 @@ update_inserted_breakpoint_locations (void)
to select an inferior to insert breakpoint to. In fact, even
if we aren't attached to any process yet, we should still
insert breakpoints. */
if (!gdbarch_has_global_breakpoints (target_gdbarch)
if (!gdbarch_has_global_breakpoints (target_gdbarch ())
&& ptid_equal (inferior_ptid, null_ptid))
continue;
@ -2851,7 +2851,7 @@ insert_breakpoint_locations (void)
to select an inferior to insert breakpoint to. In fact, even
if we aren't attached to any process yet, we should still
insert breakpoints. */
if (!gdbarch_has_global_breakpoints (target_gdbarch)
if (!gdbarch_has_global_breakpoints (target_gdbarch ())
&& ptid_equal (inferior_ptid, null_ptid))
continue;
@ -3732,7 +3732,7 @@ breakpoint_init_inferior (enum inf_context context)
/* If breakpoint locations are shared across processes, then there's
nothing to do. */
if (gdbarch_has_global_breakpoints (target_gdbarch))
if (gdbarch_has_global_breakpoints (target_gdbarch ()))
return;
ALL_BP_LOCATIONS (bl, blp_tmp)
@ -5936,7 +5936,7 @@ print_one_breakpoint_location (struct breakpoint *b,
if (loc != NULL
&& !header_of_multiple
&& (allflag
|| (!gdbarch_has_global_breakpoints (target_gdbarch)
|| (!gdbarch_has_global_breakpoints (target_gdbarch ())
&& (number_of_program_spaces () > 1
|| number_of_inferiors () > 1)
/* LOC is for existing B, it cannot be in
@ -6596,7 +6596,7 @@ static int
breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
struct address_space *aspace2, CORE_ADDR addr2)
{
return ((gdbarch_has_global_breakpoints (target_gdbarch)
return ((gdbarch_has_global_breakpoints (target_gdbarch ())
|| aspace1 == aspace2)
&& addr1 == addr2);
}
@ -6611,7 +6611,7 @@ breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
int len1, struct address_space *aspace2,
CORE_ADDR addr2)
{
return ((gdbarch_has_global_breakpoints (target_gdbarch)
return ((gdbarch_has_global_breakpoints (target_gdbarch ())
|| aspace1 == aspace2)
&& addr2 >= addr1 && addr2 < addr1 + len1);
}
@ -12529,7 +12529,7 @@ update_global_location_list (int should_insert)
if (breakpoints_always_inserted_mode ()
&& (have_live_inferiors ()
|| (gdbarch_has_global_breakpoints (target_gdbarch))))
|| (gdbarch_has_global_breakpoints (target_gdbarch ()))))
{
if (should_insert)
insert_breakpoint_locations ();

14
gdb/bsd-uthread.c
View File

@ -93,7 +93,7 @@ bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
static void
bsd_uthread_check_magic (CORE_ADDR addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);
if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
@ -137,7 +137,7 @@ bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
static int
bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR addr;
addr = bsd_uthread_lookup_address (name, objfile);
@ -150,7 +150,7 @@ bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
static CORE_ADDR
bsd_uthread_read_memory_address (CORE_ADDR addr)
{
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
return read_memory_typed_address (addr, ptr_type);
}
@ -161,7 +161,7 @@ bsd_uthread_read_memory_address (CORE_ADDR addr)
static int
bsd_uthread_activate (struct objfile *objfile)
{
struct gdbarch *gdbarch = target_gdbarch;
struct gdbarch *gdbarch = target_gdbarch ();
struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
/* Skip if the thread stratum has already been activated. */
@ -349,7 +349,7 @@ static ptid_t
bsd_uthread_wait (struct target_ops *ops,
ptid_t ptid, struct target_waitstatus *status, int options)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR addr;
struct target_ops *beneath = find_target_beneath (ops);
@ -407,7 +407,7 @@ bsd_uthread_resume (struct target_ops *ops,
static int
bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct target_ops *beneath = find_target_beneath (ops);
CORE_ADDR addr = ptid_get_tid (inferior_ptid);
@ -484,7 +484,7 @@ static char *bsd_uthread_state[] =
static char *
bsd_uthread_extra_thread_info (struct thread_info *info)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR addr = ptid_get_tid (info->ptid);
if (addr != 0)

4
gdb/cli/cli-dump.c
View File

@ -486,10 +486,10 @@ restore_section_callback (bfd *ibfd, asection *isec, void *args)
if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
printf_filtered (" into memory (%s to %s)\n",
paddress (target_gdbarch,
paddress (target_gdbarch (),
(unsigned long) sec_start
+ sec_offset + data->load_offset),
paddress (target_gdbarch,
paddress (target_gdbarch (),
(unsigned long) sec_start + sec_offset
+ data->load_offset + sec_load_count));
else

4
gdb/common/agent.c
View File

@ -125,7 +125,7 @@ agent_get_helper_thread_id (void)
(unsigned char *) &helper_thread_id,
sizeof helper_thread_id))
#else
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte buf[4];
if (target_read_memory (ipa_sym_addrs.addr_helper_thread_id,
@ -332,7 +332,7 @@ agent_capability_check (enum agent_capa agent_capa)
(unsigned char *) &agent_capability,
sizeof agent_capability))
#else
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte buf[4];
if (target_read_memory (ipa_sym_addrs.addr_capability,

4
gdb/corefile.c
View File

@ -203,11 +203,11 @@ memory_error (int status, CORE_ADDR memaddr)
bounds. */
throw_error (MEMORY_ERROR,
_("Cannot access memory at address %s"),
paddress (target_gdbarch, memaddr));
paddress (target_gdbarch (), memaddr));
else
throw_error (MEMORY_ERROR,
_("Error accessing memory address %s: %s."),
paddress (target_gdbarch, memaddr),
paddress (target_gdbarch (), memaddr),
safe_strerror (status));
}

10
gdb/darwin-nat-info.c
View File

@ -573,8 +573,8 @@ darwin_debug_regions (task_t task, mach_vm_address_t address, int max)
if (print)
{
printf_filtered (_("%s-%s %s/%s %s %s %s"),
paddress (target_gdbarch, prev_address),
paddress (target_gdbarch, prev_address + prev_size),
paddress (target_gdbarch (), prev_address),
paddress (target_gdbarch (), prev_address + prev_size),
unparse_protection (prev_info.protection),
unparse_protection (prev_info.max_protection),
unparse_inheritance (prev_info.inheritance),
@ -623,7 +623,7 @@ darwin_debug_regions_recurse (task_t task)
table_chain = make_cleanup_ui_out_table_begin_end (uiout, 9, -1, "regions");
if (gdbarch_addr_bit (target_gdbarch) <= 32)
if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
{
ui_out_table_header (uiout, 10, ui_left, "start", "Start");
ui_out_table_header (uiout, 10, ui_left, "end", "End");
@ -659,8 +659,8 @@ darwin_debug_regions_recurse (task_t task)
break;
row_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "regions-row");
ui_out_field_core_addr (uiout, "start", target_gdbarch, r_start);
ui_out_field_core_addr (uiout, "end", target_gdbarch, r_start + r_size);
ui_out_field_core_addr (uiout, "start", target_gdbarch (), r_start);
ui_out_field_core_addr (uiout, "end", target_gdbarch (), r_start + r_size);
ui_out_field_string (uiout, "min-prot",
unparse_protection (r_info.protection));
ui_out_field_string (uiout, "max-prot",

4
gdb/dcache.c
View File

@ -589,7 +589,7 @@ dcache_print_line (int index)
db = (struct dcache_block *) n->value;
printf_filtered (_("Line %d: address %s [%d hits]\n"),
index, paddress (target_gdbarch, db->addr), db->refs);
index, paddress (target_gdbarch (), db->addr), db->refs);
for (j = 0; j < last_cache->line_size; j++)
{
@ -647,7 +647,7 @@ dcache_info (char *exp, int tty)
struct dcache_block *db = (struct dcache_block *) n->value;
printf_filtered (_("Line %d: address %s [%d hits]\n"),
i, paddress (target_gdbarch, db->addr), db->refs);
i, paddress (target_gdbarch (), db->addr), db->refs);
i++;
refcount += db->refs;

6
gdb/dsrec.c
View File

@ -104,8 +104,8 @@ load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
have also been used. cagney 1999-09-01 */
printf_filtered ("%s\t: %s .. %s ",
section_name,
paddress (target_gdbarch, addr),
paddress (target_gdbarch, addr + size));
paddress (target_gdbarch (), addr),
paddress (target_gdbarch (), addr + size));
gdb_flush (gdb_stdout);
data_count += size;
@ -259,7 +259,7 @@ make_srec (char *srec, CORE_ADDR targ_addr, bfd *abfd, asection *sect,
else
internal_error (__FILE__, __LINE__,
_("make_srec: Bad address (%s), or bad flags (0x%x)."),
paddress (target_gdbarch, targ_addr), flags);
paddress (target_gdbarch (), targ_addr), flags);
/* Now that we know the address size, we can figure out how much
data this record can hold. */

2
gdb/exec.c
View File

@ -767,7 +767,7 @@ exec_files_info (struct target_ops *t)
if (vmap)
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
struct vmap *vp;
printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);

2
gdb/fbsd-nat.c
View File

@ -125,7 +125,7 @@ fbsd_find_memory_regions (find_memory_region_ftype func, void *obfd)
{
fprintf_filtered (gdb_stdout,
"Save segment, %ld bytes at %s (%c%c%c)\n",
size, paddress (target_gdbarch, start),
size, paddress (target_gdbarch (), start),
read ? 'r' : '-',
write ? 'w' : '-',
exec ? 'x' : '-');

2
gdb/filesystem.c
View File

@ -39,7 +39,7 @@ effective_target_file_system_kind (void)
{
if (target_file_system_kind == file_system_kind_auto)
{
if (gdbarch_has_dos_based_file_system (target_gdbarch))
if (gdbarch_has_dos_based_file_system (target_gdbarch ()))
return file_system_kind_dos_based;
else
return file_system_kind_unix;

22
gdb/gcore.c
View File

@ -75,10 +75,10 @@ write_gcore_file (bfd *obfd)
/* FIXME: uweigand/2011-10-06: All architectures that support core file
generation should be converted to gdbarch_make_corefile_notes; at that
point, the target vector method can be removed. */
if (!gdbarch_make_corefile_notes_p (target_gdbarch))
if (!gdbarch_make_corefile_notes_p (target_gdbarch ()))
note_data = target_make_corefile_notes (obfd, &note_size);
else
note_data = gdbarch_make_corefile_notes (target_gdbarch, obfd, &note_size);
note_data = gdbarch_make_corefile_notes (target_gdbarch (), obfd, &note_size);
if (note_data == NULL || note_size == 0)
error (_("Target does not support core file generation."));
@ -165,7 +165,7 @@ default_gcore_mach (void)
return 0;
#else
const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch);
const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch ());
if (bfdarch != NULL)
return bfdarch->mach;
@ -179,7 +179,7 @@ default_gcore_mach (void)
static enum bfd_architecture
default_gcore_arch (void)
{
const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch);
const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch ());
if (bfdarch != NULL)
return bfdarch->arch;
@ -193,8 +193,8 @@ static const char *
default_gcore_target (void)
{
/* The gdbarch may define a target to use for core files. */
if (gdbarch_gcore_bfd_target_p (target_gdbarch))
return gdbarch_gcore_bfd_target (target_gdbarch);
if (gdbarch_gcore_bfd_target_p (target_gdbarch ()))
return gdbarch_gcore_bfd_target (target_gdbarch ());
/* Otherwise, try to fall back to the exec_bfd target. This will probably
not work for non-ELF targets. */
@ -398,7 +398,7 @@ gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read,
if (info_verbose)
{
fprintf_filtered (gdb_stdout, "Ignore segment, %s bytes at %s\n",
plongest (size), paddress (target_gdbarch, vaddr));
plongest (size), paddress (target_gdbarch (), vaddr));
}
return 0;
@ -458,7 +458,7 @@ gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read,
if (info_verbose)
{
fprintf_filtered (gdb_stdout, "Save segment, %s bytes at %s\n",
plongest (size), paddress (target_gdbarch, vaddr));
plongest (size), paddress (target_gdbarch (), vaddr));
}
bfd_set_section_size (obfd, osec, size);
@ -554,7 +554,7 @@ gcore_copy_callback (bfd *obfd, asection *osec, void *ignored)
warning (_("Memory read failed for corefile "
"section, %s bytes at %s."),
plongest (size),
paddress (target_gdbarch, bfd_section_vma (obfd, osec)));
paddress (target_gdbarch (), bfd_section_vma (obfd, osec)));
break;
}
if (!bfd_set_section_contents (obfd, osec, memhunk, offset, size))
@ -575,8 +575,8 @@ static int
gcore_memory_sections (bfd *obfd)
{
/* Try gdbarch method first, then fall back to target method. */
if (!gdbarch_find_memory_regions_p (target_gdbarch)
|| gdbarch_find_memory_regions (target_gdbarch,
if (!gdbarch_find_memory_regions_p (target_gdbarch ())
|| gdbarch_find_memory_regions (target_gdbarch (),
gcore_create_callback, obfd) != 0)
{
if (target_find_memory_regions (gcore_create_callback, obfd) != 0)

4
gdb/gdbarch.c
View File

@ -4675,10 +4675,10 @@ deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch)
registers_changed ();
}
/* Helper for 'target_gdbarch'. */
/* Return the current inferior's arch. */
struct gdbarch *
get_target_gdbarch (void)
target_gdbarch (void)
{
return current_inferior ()->gdbarch;
}

3
gdb/gdbarch.h
View File

@ -71,8 +71,7 @@ struct stap_parse_info;
gdbarch. */
/* This is a convenience wrapper for 'current_inferior ()->gdbarch'. */
#define target_gdbarch get_target_gdbarch ()
extern struct gdbarch *get_target_gdbarch (void);
extern struct gdbarch *target_gdbarch (void);
/* The initial, default architecture. It uses host values (for want of a better
choice). */

7
gdb/gdbarch.sh
View File

@ -1089,8 +1089,7 @@ struct stap_parse_info;
gdbarch. */
/* This is a convenience wrapper for 'current_inferior ()->gdbarch'. */
#define target_gdbarch get_target_gdbarch ()
extern struct gdbarch *get_target_gdbarch (void);
extern struct gdbarch *target_gdbarch (void);
/* The initial, default architecture. It uses host values (for want of a better
choice). */
@ -2291,10 +2290,10 @@ deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch)
registers_changed ();
}
/* Helper for 'target_gdbarch'. */
/* Return the current inferior's arch. */
struct gdbarch *
get_target_gdbarch (void)
target_gdbarch (void)
{
return current_inferior ()->gdbarch;
}

2
gdb/gnu-nat.c
View File

@ -2491,7 +2491,7 @@ gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
{
inf_debug (gnu_current_inf, "%s %s[%d] %s %s",
write ? "writing" : "reading",
paddress (target_gdbarch, memaddr), len,
paddress (target_gdbarch (), memaddr), len,
write ? "<--" : "-->", host_address_to_string (myaddr));
if (write)
return gnu_write_inferior (task, memaddr, myaddr, len);

8
gdb/i386-darwin-nat.c
View File

@ -415,7 +415,7 @@ i386_darwin_dr_get_control (void)
void
darwin_check_osabi (darwin_inferior *inf, thread_t thread)
{
if (gdbarch_osabi (target_gdbarch) == GDB_OSABI_UNKNOWN)
if (gdbarch_osabi (target_gdbarch ()) == GDB_OSABI_UNKNOWN)
{
/* Attaching to a process. Let's figure out what kind it is. */
x86_thread_state_t gp_regs;
@ -433,7 +433,7 @@ darwin_check_osabi (darwin_inferior *inf, thread_t thread)
gdbarch_info_init (&info);
gdbarch_info_fill (&info);
info.byte_order = gdbarch_byte_order (target_gdbarch);
info.byte_order = gdbarch_byte_order (target_gdbarch ());
info.osabi = GDB_OSABI_DARWIN;
if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
@ -457,7 +457,7 @@ darwin_check_osabi (darwin_inferior *inf, thread_t thread)
static int
i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */
gdb_byte buf[sizeof (darwin_syscall)];
@ -490,7 +490,7 @@ i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
static int
amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */
gdb_byte buf[sizeof (darwin_syscall)];

2
gdb/i386-nat.c
View File

@ -318,7 +318,7 @@ i386_show_dr (struct i386_debug_reg_state *state,
const char *func, CORE_ADDR addr,
int len, enum target_hw_bp_type type)
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
int i;
puts_unfiltered (func);

2
gdb/ia64-vms-tdep.c
View File

@ -33,7 +33,7 @@ ia64_vms_find_proc_info_x (unw_addr_space_t as, unw_word_t ip,
unw_proc_info_t *pi,
int need_unwind_info, void *arg)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
unw_dyn_info_t di;
int ret;
gdb_byte buf[32];

6
gdb/inf-ptrace.c
View File

@ -649,11 +649,11 @@ static int
inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
struct type *int_type = builtin_type (target_gdbarch)->builtin_int;
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *int_type = builtin_type (target_gdbarch ())->builtin_int;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
const int sizeof_auxv_type = TYPE_LENGTH (int_type);
const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte *ptr = *readptr;
if (endptr == ptr)

8
gdb/infcmd.c
View File

@ -469,7 +469,7 @@ post_create_inferior (struct target_ops *target, int from_tty)
/* If the solist is global across processes, there's no need to
refetch it here. */
if (!gdbarch_has_global_solist (target_gdbarch))
if (!gdbarch_has_global_solist (target_gdbarch ()))
{
#ifdef SOLIB_ADD
SOLIB_ADD (NULL, 0, target, auto_solib_add);
@ -1839,7 +1839,7 @@ program_info (char *args, int from_tty)
target_files_info ();
printf_filtered (_("Program stopped at %s.\n"),
paddress (target_gdbarch, stop_pc));
paddress (target_gdbarch (), stop_pc));
if (tp->control.stop_step)
printf_filtered (_("It stopped after being stepped.\n"));
else if (stat != 0)
@ -2542,7 +2542,7 @@ attach_command (char *args, int from_tty)
dont_repeat (); /* Not for the faint of heart */
if (gdbarch_has_global_solist (target_gdbarch))
if (gdbarch_has_global_solist (target_gdbarch ()))
/* Don't complain if all processes share the same symbol
space. */
;
@ -2732,7 +2732,7 @@ detach_command (char *args, int from_tty)
/* If the solist is global across inferiors, don't clear it when we
detach from a single inferior. */
if (!gdbarch_has_global_solist (target_gdbarch))
if (!gdbarch_has_global_solist (target_gdbarch ()))
no_shared_libraries (NULL, from_tty);
/* If we still have inferiors to debug, then don't mess with their

6
gdb/jit.c
View File

@ -757,7 +757,7 @@ jit_object_close_impl (struct gdb_symbol_callbacks *cb,
priv_data = cb->priv_data;
objfile = allocate_objfile (NULL, 0);
objfile->gdbarch = target_gdbarch;
objfile->gdbarch = target_gdbarch ();
terminate_minimal_symbol_table (objfile);
@ -1290,7 +1290,7 @@ jit_inferior_init (struct gdbarch *gdbarch)
void
jit_inferior_created_hook (void)
{
jit_inferior_init (target_gdbarch);
jit_inferior_init (target_gdbarch ());
}
/* Exported routine to call to re-set the jit breakpoints,
@ -1299,7 +1299,7 @@ jit_inferior_created_hook (void)
void
jit_breakpoint_re_set (void)
{
jit_breakpoint_re_set_internal (target_gdbarch,
jit_breakpoint_re_set_internal (target_gdbarch (),
get_jit_inferior_data ());
}

6
gdb/linux-nat.c
View File

@ -4376,7 +4376,7 @@ linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
{
/* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
converted to gdbarch_core_regset_sections, this function can go away. */
return linux_make_corefile_notes (target_gdbarch, obfd, note_size,
return linux_make_corefile_notes (target_gdbarch (), obfd, note_size,
linux_nat_collect_thread_registers);
}
@ -4431,7 +4431,7 @@ linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
static LONGEST
spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, LONGEST len)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
LONGEST pos = 0;
LONGEST written = 0;
char path[128];
@ -4640,7 +4640,7 @@ linux_xfer_partial (struct target_ops *ops, enum target_object object,
if (object == TARGET_OBJECT_MEMORY)
{
int addr_bit = gdbarch_addr_bit (target_gdbarch);
int addr_bit = gdbarch_addr_bit (target_gdbarch ());
if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
offset &= ((ULONGEST) 1 << addr_bit) - 1;

2
gdb/linux-tdep.c
View File

@ -667,7 +667,7 @@ linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
"proxydma_info",
};
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte *spu_ids;
LONGEST i, j, size;

4
gdb/linux-thread-db.c
View File

@ -544,13 +544,13 @@ enable_thread_event (int event, CORE_ADDR *bp)
/* Set up the breakpoint. */
gdb_assert (exec_bfd);
(*bp) = (gdbarch_convert_from_func_ptr_addr
(target_gdbarch,
(target_gdbarch (),
/* Do proper sign extension for the target. */
(bfd_get_sign_extend_vma (exec_bfd) > 0
? (CORE_ADDR) (intptr_t) notify.u.bptaddr
: (CORE_ADDR) (uintptr_t) notify.u.bptaddr),
&current_target));
create_thread_event_breakpoint (target_gdbarch, *bp);
create_thread_event_breakpoint (target_gdbarch (), *bp);
return TD_OK;
}

8
gdb/m32r-rom.c
View File

@ -79,7 +79,7 @@ m32r_load_section (bfd *abfd, asection *s, void *obj)
unsigned int *data_count = obj;
if (s->flags & SEC_LOAD)
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
bfd_size_type section_size = bfd_section_size (abfd, s);
bfd_vma section_base = bfd_section_lma (abfd, s);
unsigned int buffer, i;
@ -89,7 +89,7 @@ m32r_load_section (bfd *abfd, asection *s, void *obj)
printf_filtered ("Loading section %s, size 0x%lx lma ",
bfd_section_name (abfd, s),
(unsigned long) section_size);
fputs_filtered (paddress (target_gdbarch, section_base), gdb_stdout);
fputs_filtered (paddress (target_gdbarch (), section_base), gdb_stdout);
printf_filtered ("\n");
gdb_flush (gdb_stdout);
monitor_printf ("%s mw\r", phex_nz (section_base, addr_size));
@ -149,7 +149,7 @@ m32r_load (char *filename, int from_tty)
printf_filtered ("Loading section %s, size 0x%lx vma ",
bfd_section_name (abfd, s), section_size);
fputs_filtered (paddress (target_gdbarch, section_base), gdb_stdout);
fputs_filtered (paddress (target_gdbarch (), section_base), gdb_stdout);
printf_filtered ("\n");
gdb_flush (gdb_stdout);
monitor_printf ("%x mw\r", section_base);
@ -548,7 +548,7 @@ m32r_upload_command (char *args, int from_tty)
printf_filtered ("Loading section %s, size 0x%lx lma ",
bfd_section_name (abfd, s),
(unsigned long) section_size);
fputs_filtered (paddress (target_gdbarch, section_base),
fputs_filtered (paddress (target_gdbarch (), section_base),
gdb_stdout);
printf_filtered ("\n");
gdb_flush (gdb_stdout);

8
gdb/memattr.c
View File

@ -431,10 +431,10 @@ mem_info_command (char *args, int from_tty)
printf_filtered ("Num ");
printf_filtered ("Enb ");
printf_filtered ("Low Addr ");
if (gdbarch_addr_bit (target_gdbarch) > 32)
if (gdbarch_addr_bit (target_gdbarch ()) > 32)
printf_filtered (" ");
printf_filtered ("High Addr ");
if (gdbarch_addr_bit (target_gdbarch) > 32)
if (gdbarch_addr_bit (target_gdbarch ()) > 32)
printf_filtered (" ");
printf_filtered ("Attrs ");
printf_filtered ("\n");
@ -446,14 +446,14 @@ mem_info_command (char *args, int from_tty)
printf_filtered ("%-3d %-3c\t",
m->number,
m->enabled_p ? 'y' : 'n');
if (gdbarch_addr_bit (target_gdbarch) <= 32)
if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
tmp = hex_string_custom ((unsigned long) m->lo, 8);
else
tmp = hex_string_custom ((unsigned long) m->lo, 16);
printf_filtered ("%s ", tmp);
if (gdbarch_addr_bit (target_gdbarch) <= 32)
if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
{
if (m->hi == 0)
tmp = "0x100000000";

4
gdb/mep-tdep.c
View File

@ -263,7 +263,7 @@ me_module_register_set (CONFIG_ATTR me_module,
mask contains any of the me_module's coprocessor ISAs,
specifically excluding the generic coprocessor register sets. */
CGEN_CPU_DESC desc = gdbarch_tdep (target_gdbarch)->cpu_desc;
CGEN_CPU_DESC desc = gdbarch_tdep (target_gdbarch ())->cpu_desc;
const CGEN_HW_ENTRY *hw;
if (me_module == CONFIG_NONE)
@ -854,7 +854,7 @@ current_me_module (void)
return regval;
}
else
return gdbarch_tdep (target_gdbarch)->me_module;
return gdbarch_tdep (target_gdbarch ())->me_module;
}

6
gdb/mi/mi-interp.c
View File

@ -778,7 +778,7 @@ mi_solib_loaded (struct so_list *solib)
struct mi_interp *mi = top_level_interpreter_data ();
target_terminal_ours ();
if (gdbarch_has_global_solist (target_gdbarch))
if (gdbarch_has_global_solist (target_gdbarch ()))
fprintf_unfiltered (mi->event_channel,
"library-loaded,id=\"%s\",target-name=\"%s\","
"host-name=\"%s\",symbols-loaded=\"%d\"",
@ -802,7 +802,7 @@ mi_solib_unloaded (struct so_list *solib)
struct mi_interp *mi = top_level_interpreter_data ();
target_terminal_ours ();
if (gdbarch_has_global_solist (target_gdbarch))
if (gdbarch_has_global_solist (target_gdbarch ()))
fprintf_unfiltered (mi->event_channel,
"library-unloaded,id=\"%s\",target-name=\"%s\","
"host-name=\"%s\"",
@ -865,7 +865,7 @@ mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
ui_out_redirect (mi_uiout, mi->event_channel);
ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch, memaddr);
ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
ui_out_field_fmt (mi_uiout, "len", "0x%zx", len);
/* Append 'type=code' into notification if MEMADDR falls in the range of

2
gdb/microblaze-tdep.c
View File

@ -123,7 +123,7 @@ microblaze_register_type (struct gdbarch *gdbarch, int regnum)
static unsigned long
microblaze_fetch_instruction (CORE_ADDR pc)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte buf[4];
/* If we can't read the instruction at PC, return zero. */

6
gdb/mips-linux-nat.c
View File

@ -688,7 +688,7 @@ mips_show_dr (const char *func, CORE_ADDR addr,
puts_unfiltered (func);
if (addr || len)
printf_unfiltered (" (addr=%s, len=%d, type=%s)",
paddress (target_gdbarch, addr), len,
paddress (target_gdbarch (), addr), len,
type == hw_write ? "data-write"
: (type == hw_read ? "data-read"
: (type == hw_access ? "data-read/write"
@ -698,9 +698,9 @@ mips_show_dr (const char *func, CORE_ADDR addr,
for (i = 0; i < MAX_DEBUG_REGISTER; i++)
printf_unfiltered ("\tDR%d: lo=%s, hi=%s\n", i,
paddress (target_gdbarch,
paddress (target_gdbarch (),
get_watchlo (&watch_mirror, i)),
paddress (target_gdbarch,
paddress (target_gdbarch (),
get_watchhi (&watch_mirror, i)));
}

4
gdb/mips-linux-tdep.c
View File

@ -682,8 +682,8 @@ mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
{
unsigned char buf[28], *p;
ULONGEST insn, insn1;
int n64 = (mips_abi (target_gdbarch) == MIPS_ABI_N64);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
int n64 = (mips_abi (target_gdbarch ()) == MIPS_ABI_N64);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
read_memory (pc - 12, buf, 28);

10
gdb/mips-tdep.c
View File

@ -1087,7 +1087,7 @@ static void
show_mask_address (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
deprecated_show_value_hack (file, from_tty, c, value);
switch (mask_address_var)
@ -6652,7 +6652,7 @@ show_mipsfpu_command (char *args, int from_tty)
{
char *fpu;
if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_mips)
if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_mips)
{
printf_unfiltered
("The MIPS floating-point coprocessor is unknown "
@ -6660,7 +6660,7 @@ show_mipsfpu_command (char *args, int from_tty)
return;
}
switch (MIPS_FPU_TYPE (target_gdbarch))
switch (MIPS_FPU_TYPE (target_gdbarch ()))
{
case MIPS_FPU_SINGLE:
fpu = "single-precision";
@ -8681,7 +8681,7 @@ show_mips_abi (struct ui_file *file,
struct cmd_list_element *ignored_cmd,
const char *ignored_value)
{
if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_mips)
if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_mips)
fprintf_filtered
(file,
"The MIPS ABI is unknown because the current architecture "
@ -8689,7 +8689,7 @@ show_mips_abi (struct ui_file *file,
else
{
enum mips_abi global_abi = global_mips_abi ();
enum mips_abi actual_abi = mips_abi (target_gdbarch);
enum mips_abi actual_abi = mips_abi (target_gdbarch ());
const char *actual_abi_str = mips_abi_strings[actual_abi];
if (global_abi == MIPS_ABI_UNKNOWN)

18
gdb/monitor.c
View File

@ -217,11 +217,11 @@ monitor_error (char *function, char *message,
if (final_char)
error (_("%s (%s): %s: %s%c"),
function, paddress (target_gdbarch, memaddr),
function, paddress (target_gdbarch (), memaddr),
message, safe_string, final_char);
else
error (_("%s (%s): %s: %s"),
function, paddress (target_gdbarch, memaddr),
function, paddress (target_gdbarch (), memaddr),
message, safe_string);
}
@ -256,7 +256,7 @@ fromhex (int a)
static void
monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
{
int addr_bit = gdbarch_addr_bit (target_gdbarch);
int addr_bit = gdbarch_addr_bit (target_gdbarch ());
char format[10];
char fmt;
char *p;
@ -1440,15 +1440,15 @@ monitor_files_info (struct target_ops *ops)
static int
monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
unsigned int val, hostval;
char *cmd;
int i;
monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch, memaddr));
monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch (), memaddr));
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
/* Use memory fill command for leading 0 bytes. */
@ -1707,7 +1707,7 @@ monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
static int
monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
unsigned int val;
char membuf[sizeof (int) * 2 + 1];
char *p;
@ -1852,11 +1852,11 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
}
monitor_debug ("MON read block ta(%s) ha(%s) %d\n",
paddress (target_gdbarch, memaddr),
paddress (target_gdbarch (), memaddr),
host_address_to_string (myaddr), len);
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
return monitor_read_memory_single (memaddr, myaddr, len);

4
gdb/moxie-tdep.c
View File

@ -505,7 +505,7 @@ moxie_process_readu (CORE_ADDR addr, char *buf,
if (record_debug)
printf_unfiltered (_("Process record: error reading memory at "
"addr 0x%s len = %d.\n"),
paddress (target_gdbarch, addr), length);
paddress (target_gdbarch (), addr), length);
return -1;
}
@ -528,7 +528,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
if (record_debug > 1)
fprintf_unfiltered (gdb_stdlog, "Process record: moxie_process_record "
"addr = 0x%s\n",
paddress (target_gdbarch, addr));
paddress (target_gdbarch (), addr));
inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order);

2
gdb/nto-procfs.c
View File

@ -197,7 +197,7 @@ procfs_open (char *arg, int from_tty)
{
if (sysinfo->type !=
nto_map_arch_to_cputype (gdbarch_bfd_arch_info
(target_gdbarch)->arch_name))
(target_gdbarch ())->arch_name))
error (_("Invalid target CPU."));
}
}

26
gdb/nto-tdep.c
View File

@ -94,14 +94,14 @@ nto_find_and_open_solib (char *solib, unsigned o_flags, char **temp_pathname)
"%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
nto_root = nto_target ();
if (strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name, "i386") == 0)
if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
{
arch = "x86";
endian = "";
}
else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name,
else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
"rs6000") == 0
|| strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name,
|| strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
"powerpc") == 0)
{
arch = "ppc";
@ -109,8 +109,8 @@ nto_find_and_open_solib (char *solib, unsigned o_flags, char **temp_pathname)
}
else
{
arch = gdbarch_bfd_arch_info (target_gdbarch)->arch_name;
endian = gdbarch_byte_order (target_gdbarch)
arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
endian = gdbarch_byte_order (target_gdbarch ())
== BFD_ENDIAN_BIG ? "be" : "le";
}
@ -150,14 +150,14 @@ nto_init_solib_absolute_prefix (void)
const char *arch;
nto_root = nto_target ();
if (strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name, "i386") == 0)
if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
{
arch = "x86";
endian = "";
}
else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name,
else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
"rs6000") == 0
|| strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name,
|| strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
"powerpc") == 0)
{
arch = "ppc";
@ -165,8 +165,8 @@ nto_init_solib_absolute_prefix (void)
}
else
{
arch = gdbarch_bfd_arch_info (target_gdbarch)->arch_name;
endian = gdbarch_byte_order (target_gdbarch)
arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
endian = gdbarch_byte_order (target_gdbarch ())
== BFD_ENDIAN_BIG ? "be" : "le";
}
@ -261,7 +261,7 @@ lm_addr (struct so_list *so)
if (so->lm_info->l_addr == (CORE_ADDR)-1)
{
struct link_map_offsets *lmo = nto_fetch_link_map_offsets ();
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
so->lm_info->l_addr =
extract_typed_address (so->lm_info->lm + lmo->l_addr_offset, ptr_type);
@ -272,12 +272,12 @@ lm_addr (struct so_list *so)
static CORE_ADDR
nto_truncate_ptr (CORE_ADDR addr)
{
if (gdbarch_ptr_bit (target_gdbarch) == sizeof (CORE_ADDR) * 8)
if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
/* We don't need to truncate anything, and the bit twiddling below
will fail due to overflow problems. */
return addr;
else
return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch)) - 1);
return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
}
static Elf_Internal_Phdr *

2
gdb/ppc-linux-nat.c
View File

@ -2394,7 +2394,7 @@ ppc_linux_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
int sizeof_auxv_field = ppc_linux_target_wordsize ();
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte *ptr = *readptr;
if (endptr == ptr)

8
gdb/proc-service.c
View File

@ -269,7 +269,7 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
struct regcache *regcache;
inferior_ptid = BUILD_LWP (lwpid, ptid_get_pid (ph->ptid));
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
target_fetch_registers (regcache, -1);
fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
@ -288,7 +288,7 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, const prgregset_t gregset)
struct regcache *regcache;
inferior_ptid = BUILD_LWP (lwpid, ptid_get_pid (ph->ptid));
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
supply_gregset (regcache, (const gdb_gregset_t *) gregset);
target_store_registers (regcache, -1);
@ -308,7 +308,7 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
struct regcache *regcache;
inferior_ptid = BUILD_LWP (lwpid, ptid_get_pid (ph->ptid));
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
target_fetch_registers (regcache, -1);
fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
@ -328,7 +328,7 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
struct regcache *regcache;
inferior_ptid = BUILD_LWP (lwpid, ptid_get_pid (ph->ptid));
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
target_store_registers (regcache, -1);

30
gdb/procfs.c
View File

@ -159,7 +159,7 @@ static int
procfs_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte *ptr = *readptr;
if (endptr == ptr)
@ -1206,12 +1206,12 @@ proc_watchpoint_address (procinfo *pi, CORE_ADDR *addr)
return 0;
#ifdef NEW_PROC_API
*addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch,
builtin_type (target_gdbarch)->builtin_data_ptr,
*addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch (),
builtin_type (target_gdbarch ())->builtin_data_ptr,
(gdb_byte *) &pi->prstatus.pr_lwp.pr_info.si_addr);
#else
*addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch,
builtin_type (target_gdbarch)->builtin_data_ptr,
*addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch (),
builtin_type (target_gdbarch ())->builtin_data_ptr,
(gdb_byte *) &pi->prstatus.pr_info.si_addr);
#endif
return 1;
@ -2455,11 +2455,11 @@ proc_parent_pid (procinfo *pi)
static void *
procfs_address_to_host_pointer (CORE_ADDR addr)
{
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
void *ptr;
gdb_assert (sizeof (ptr) == TYPE_LENGTH (ptr_type));
gdbarch_address_to_pointer (target_gdbarch, ptr_type,
gdbarch_address_to_pointer (target_gdbarch (), ptr_type,
(gdb_byte *) &ptr, addr);
return ptr;
}
@ -3430,7 +3430,7 @@ remove_dbx_link_breakpoint (void)
if (dbx_link_bpt_addr == 0)
return;
if (deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt) != 0)
if (deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt) != 0)
warning (_("Unable to remove __dbx_link breakpoint."));
dbx_link_bpt_addr = 0;
@ -3503,7 +3503,7 @@ insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored)
{
/* Insert the breakpoint. */
dbx_link_bpt_addr = sym_addr;
dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch, NULL,
dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch (), NULL,
sym_addr);
if (dbx_link_bpt == NULL)
{
@ -4118,7 +4118,7 @@ invalidate_cache (procinfo *parent, procinfo *pi, void *ptr)
if (!proc_set_gregs (pi)) /* flush gregs cache */
proc_warn (pi, "target_resume, set_gregs",
__LINE__);
if (gdbarch_fp0_regnum (target_gdbarch) >= 0)
if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
if (pi->fpregs_dirty)
if (parent == NULL ||
proc_get_current_thread (parent) != pi->tid)
@ -4396,7 +4396,7 @@ procfs_mourn_inferior (struct target_ops *ops)
if (dbx_link_bpt != NULL)
{
deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt);
deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt);
dbx_link_bpt_addr = 0;
dbx_link_bpt = NULL;
}
@ -4881,7 +4881,7 @@ procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
procfs_address_to_host_pointer will reveal that an internal error
will be generated when the host and target pointer sizes are
different. */
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
if (sizeof (void *) != TYPE_LENGTH (ptr_type))
return 0;
@ -4938,7 +4938,7 @@ procfs_insert_watchpoint (CORE_ADDR addr, int len, int type,
struct expression *cond)
{
if (!target_have_steppable_watchpoint
&& !gdbarch_have_nonsteppable_watchpoint (target_gdbarch))
&& !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
{
/* When a hardware watchpoint fires off the PC will be left at
the instruction following the one which caused the
@ -5138,7 +5138,7 @@ info_mappings_callback (struct prmap *map, find_memory_region_ftype ignore,
pr_off = map->pr_off;
#endif
if (gdbarch_addr_bit (target_gdbarch) == 32)
if (gdbarch_addr_bit (target_gdbarch ()) == 32)
printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
(unsigned long) map->pr_vaddr,
(unsigned long) map->pr_vaddr + map->pr_size - 1,
@ -5165,7 +5165,7 @@ info_proc_mappings (procinfo *pi, int summary)
return; /* No output for summary mode. */
printf_filtered (_("Mapped address spaces:\n\n"));
if (gdbarch_ptr_bit (target_gdbarch) == 32)
if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
printf_filtered ("\t%10s %10s %10s %10s %7s\n",
"Start Addr",
" End Addr",

8
gdb/progspace.c
View File

@ -75,7 +75,7 @@ new_address_space (void)
struct address_space *
maybe_new_address_space (void)
{
int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
if (shared_aspace)
{
@ -148,7 +148,7 @@ release_program_space (struct program_space *pspace)
no_shared_libraries (NULL, 0);
exec_close ();
free_all_objfiles ();
if (!gdbarch_has_shared_address_space (target_gdbarch))
if (!gdbarch_has_shared_address_space (target_gdbarch ()))
free_address_space (pspace->aspace);
resize_section_table (&pspace->target_sections,
-resize_section_table (&pspace->target_sections, 0));
@ -432,7 +432,7 @@ number_of_program_spaces (void)
void
update_address_spaces (void)
{
int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
struct program_space *pspace;
struct inferior *inf;
@ -454,7 +454,7 @@ update_address_spaces (void)
}
for (inf = inferior_list; inf; inf = inf->next)
if (gdbarch_has_global_solist (target_gdbarch))
if (gdbarch_has_global_solist (target_gdbarch ()))
inf->aspace = maybe_new_address_space ();
else
inf->aspace = inf->pspace->aspace;

2
gdb/python/py-finishbreakpoint.c
View File

@ -392,7 +392,7 @@ bpfinishpy_handle_stop (struct bpstats *bs, int print_frame)
static void
bpfinishpy_handle_exit (struct inferior *inf)
{
struct cleanup *cleanup = ensure_python_env (target_gdbarch,
struct cleanup *cleanup = ensure_python_env (target_gdbarch (),
current_language);
iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb, NULL);

4
gdb/python/py-inferior.c
View File

@ -101,7 +101,7 @@ python_on_resume (ptid_t ptid)
{
struct cleanup *cleanup;
cleanup = ensure_python_env (target_gdbarch, current_language);
cleanup = ensure_python_env (target_gdbarch (), current_language);
if (emit_continue_event (ptid) < 0)
gdbpy_print_stack ();
@ -115,7 +115,7 @@ python_inferior_exit (struct inferior *inf)
struct cleanup *cleanup;
const LONGEST *exit_code = NULL;
cleanup = ensure_python_env (target_gdbarch, current_language);
cleanup = ensure_python_env (target_gdbarch (), current_language);
if (inf->has_exit_code)
exit_code = &inf->exit_code;

2
gdb/python/python.c
View File

@ -1280,7 +1280,7 @@ finalize_python (void *ignore)
clearer to make the needed calls explicitly here than to create a
cleanup and then mysteriously discard it. */
PyGILState_Ensure ();
python_gdbarch = target_gdbarch;
python_gdbarch = target_gdbarch ();
python_language = current_language;
Py_Finalize ();

2
gdb/ravenscar-thread.c
View File

@ -166,7 +166,7 @@ get_running_thread_id (void)
char *buf;
CORE_ADDR object_addr;
struct type *builtin_type_void_data_ptr =
builtin_type (target_gdbarch)->builtin_data_ptr;
builtin_type (target_gdbarch ())->builtin_data_ptr;
if (!object_msym)
return 0;

8
gdb/record.c
View File

@ -512,14 +512,14 @@ record_arch_list_add_mem (CORE_ADDR addr, int len)
fprintf_unfiltered (gdb_stdlog,
"Process record: add mem addr = %s len = %d to "
"record list.\n",
paddress (target_gdbarch, addr), len);
paddress (target_gdbarch (), addr), len);
if (!addr) /* FIXME: Why? Some arch must permit it... */
return 0;
rec = record_mem_alloc (addr, len);
if (record_read_memory (target_gdbarch, addr, record_get_loc (rec), len))
if (record_read_memory (target_gdbarch (), addr, record_get_loc (rec), len))
{
record_mem_release (rec);
return -1;
@ -874,7 +874,7 @@ record_open_1 (char *name, int from_tty)
error (_("Process record target can't debug inferior in non-stop mode "
"(non-stop)."));
if (!gdbarch_process_record_p (target_gdbarch))
if (!gdbarch_process_record_p (target_gdbarch ()))
error (_("Process record: the current architecture doesn't support "
"record function."));
@ -1686,7 +1686,7 @@ record_xfer_partial (struct target_ops *ops, enum target_object object,
if (!query (_("Because GDB is in replay mode, writing to memory "
"will make the execution log unusable from this "
"point onward. Write memory at address %s?"),
paddress (target_gdbarch, offset)))
paddress (target_gdbarch (), offset)))
error (_("Process record canceled the operation."));
/* Destroy the record from here forward. */

24
gdb/remote-m32r-sdi.c
View File

@ -487,7 +487,7 @@ m32r_resume (struct target_ops *ops,
else
{
buf[0] = SDI_WRITE_MEMORY;
if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
store_long_parameter (buf + 1, pc_addr);
else
store_long_parameter (buf + 1, pc_addr - 1);
@ -527,7 +527,7 @@ m32r_resume (struct target_ops *ops,
continue;
/* Set PBP. */
if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
0x00000006);
else
@ -554,7 +554,7 @@ m32r_resume (struct target_ops *ops,
store_long_parameter (buf + 5, 4);
if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
{
if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
buf[9] = dbt_bp_entry[0];
buf[10] = dbt_bp_entry[1];
@ -571,7 +571,7 @@ m32r_resume (struct target_ops *ops,
}
else
{
if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
if ((bp_addr & 2) == 0)
{
@ -618,7 +618,7 @@ m32r_resume (struct target_ops *ops,
continue;
/* DBC register. */
if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
switch (ab_type[i])
{
@ -760,7 +760,7 @@ m32r_wait (struct target_ops *ops,
if (last_pc_addr != 0xffffffff)
{
buf[0] = SDI_WRITE_MEMORY;
if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
store_long_parameter (buf + 1, last_pc_addr);
else
store_long_parameter (buf + 1, last_pc_addr - 1);
@ -789,7 +789,7 @@ m32r_wait (struct target_ops *ops,
address, we have to take care of it later. */
if ((pc_addr & 0x2) != 0)
{
if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
if ((bp_data[i][2] & 0x80) != 0)
{
@ -851,7 +851,7 @@ m32r_wait (struct target_ops *ops,
c = serial_readchar (sdi_desc, SDI_TIMEOUT);
if (c != '-' && recv_data (buf, 4) != -1)
{
if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
{
if ((buf[3] & 0x1) == 0x1)
hit_watchpoint_addr = ab_address[i];
@ -1055,10 +1055,10 @@ m32r_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
{
if (write)
fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
paddress (target_gdbarch, memaddr), len);
paddress (target_gdbarch (), memaddr), len);
else
fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
paddress (target_gdbarch, memaddr), len);
paddress (target_gdbarch (), memaddr), len);
}
if (write)
@ -1424,7 +1424,7 @@ m32r_insert_watchpoint (CORE_ADDR addr, int len, int type,
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
paddress (target_gdbarch, addr), len, type);
paddress (target_gdbarch (), addr), len, type);
for (i = 0; i < MAX_ACCESS_BREAKS; i++)
{
@ -1449,7 +1449,7 @@ m32r_remove_watchpoint (CORE_ADDR addr, int len, int type,
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
paddress (target_gdbarch, addr), len, type);
paddress (target_gdbarch (), addr), len, type);
for (i = 0; i < MAX_ACCESS_BREAKS; i++)
{

22
gdb/remote-mips.c
View File

@ -1242,7 +1242,7 @@ mips_request (int cmd,
int timeout,
char *buff)
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
char myBuff[DATA_MAXLEN + 1];
char response_string[17];
int len;
@ -1663,10 +1663,10 @@ static void
mips_open (char *name, int from_tty)
{
const char *monitor_prompt = NULL;
if (gdbarch_bfd_arch_info (target_gdbarch) != NULL
&& gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_mips)
if (gdbarch_bfd_arch_info (target_gdbarch ()) != NULL
&& gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_mips)
{
switch (gdbarch_bfd_arch_info (target_gdbarch)->mach)
switch (gdbarch_bfd_arch_info (target_gdbarch ())->mach)
{
case bfd_mach_mips4100:
case bfd_mach_mips4300:
@ -2147,7 +2147,7 @@ static int
mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
struct mem_attrib *attrib, struct target_ops *target)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int i;
CORE_ADDR addr;
int count;
@ -2479,7 +2479,7 @@ static int
mips_check_lsi_error (CORE_ADDR addr, int rerrflg)
{
struct lsi_error *err;
const char *saddr = paddress (target_gdbarch, addr);
const char *saddr = paddress (target_gdbarch (), addr);
if (rerrflg == 0) /* no error */
return 0;
@ -2547,13 +2547,13 @@ mips_common_breakpoint (%s): Unknown error: 0x%x\n",
static int
mips_common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
char buf[DATA_MAXLEN + 1];
char cmd, rcmd;
int rpid, rerrflg, rresponse, rlen;
int nfields;
addr = gdbarch_addr_bits_remove (target_gdbarch, addr);
addr = gdbarch_addr_bits_remove (target_gdbarch (), addr);
if (mips_monitor == MON_LSI)
{
@ -2581,7 +2581,7 @@ mips_common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
{
warning (_("\
mips_common_breakpoint: Attempt to clear bogus breakpoint at %s"),
paddress (target_gdbarch, addr));
paddress (target_gdbarch (), addr));
return 1;
}
@ -2732,7 +2732,7 @@ mips_common_breakpoint: Attempt to clear bogus breakpoint at %s"),
if (rresponse != 22) /* invalid argument */
fprintf_unfiltered (gdb_stderr, "\
mips_common_breakpoint (%s): Got error: 0x%x\n",
paddress (target_gdbarch, addr), rresponse);
paddress (target_gdbarch (), addr), rresponse);
return 1;
}
}
@ -2765,7 +2765,7 @@ send_srec (char *srec, int len, CORE_ADDR addr)
case 0x15: /* NACK */
fprintf_unfiltered (gdb_stderr,
"Download got a NACK at byte %s! Retrying.\n",
paddress (target_gdbarch, addr));
paddress (target_gdbarch (), addr));
continue;
default:
error (_("Download got unexpected ack char: 0x%x, retrying."),

2
gdb/remote-sim.c
View File

@ -1098,7 +1098,7 @@ gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
gdb_print_host_address (myaddr, gdb_stdout);
printf_filtered (", memaddr %s, len %d, write %d\n",
paddress (target_gdbarch, memaddr), len, write);
paddress (target_gdbarch (), memaddr), len, write);
if (remote_debug && write)
dump_mem (myaddr, len);
}

50
gdb/remote.c
View File

@ -397,9 +397,9 @@ struct packet_reg
long regnum; /* GDB's internal register number. */
LONGEST pnum; /* Remote protocol register number. */
int in_g_packet; /* Always part of G packet. */
/* long size in bytes; == register_size (target_gdbarch, regnum);
/* long size in bytes; == register_size (target_gdbarch (), regnum);
at present. */
/* char *name; == gdbarch_register_name (target_gdbarch, regnum);
/* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
at present. */
};
@ -484,7 +484,7 @@ remote_get_noisy_reply (char **buf_p,
TRY_CATCH (ex, RETURN_MASK_ALL)
{
gdbarch_relocate_instruction (target_gdbarch, &to, from);
gdbarch_relocate_instruction (target_gdbarch (), &to, from);
}
if (ex.reason >= 0)
{
@ -525,7 +525,7 @@ static struct gdbarch_data *remote_gdbarch_data_handle;
static struct remote_arch_state *
get_remote_arch_state (void)
{
return gdbarch_data (target_gdbarch, remote_gdbarch_data_handle);
return gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle);
}
/* Fetch the global remote target state. */
@ -698,7 +698,7 @@ get_remote_packet_size (void)
static struct packet_reg *
packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
{
if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch))
if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch ()))
return NULL;
else
{
@ -714,7 +714,7 @@ packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
{
int i;
for (i = 0; i < gdbarch_num_regs (target_gdbarch); i++)
for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
{
struct packet_reg *r = &rsa->regs[i];
@ -1481,7 +1481,7 @@ remote_add_inferior (int fake_pid_p, int pid, int attached)
if (attached == -1)
attached = remote_query_attached (pid);
if (gdbarch_has_global_solist (target_gdbarch))
if (gdbarch_has_global_solist (target_gdbarch ()))
{
/* If the target shares code across all inferiors, then every
attach adds a new inferior. */
@ -3338,7 +3338,7 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
/* On OSs where the list of libraries is global to all
processes, we fetch them early. */
if (gdbarch_has_global_solist (target_gdbarch))
if (gdbarch_has_global_solist (target_gdbarch ()))
solib_add (NULL, from_tty, target, auto_solib_add);
if (non_stop)
@ -3420,7 +3420,7 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
supported for non-stop; it could be, but it is tricky if
there are no stopped threads when we connect. */
if (remote_read_description_p (target)
&& gdbarch_target_desc (target_gdbarch) == NULL)
&& gdbarch_target_desc (target_gdbarch ()) == NULL)
{
target_clear_description ();
target_find_description ();
@ -3539,7 +3539,7 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
rs->starting_up = 0;
/* If breakpoints are global, insert them now. */
if (gdbarch_has_global_breakpoints (target_gdbarch)
if (gdbarch_has_global_breakpoints (target_gdbarch ())
&& breakpoints_always_inserted_mode ())
insert_breakpoints ();
}
@ -3619,12 +3619,12 @@ remote_check_symbols (struct objfile *objfile)
xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
else
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
/* If this is a function address, return the start of code
instead of any data function descriptor. */
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
sym_addr,
&current_target);
@ -5407,10 +5407,10 @@ Packet: '%s'\n"),
cached_reg.num = reg->regnum;
fieldsize = hex2bin (p, cached_reg.data,
register_size (target_gdbarch,
register_size (target_gdbarch (),
reg->regnum));
p += 2 * fieldsize;
if (fieldsize < register_size (target_gdbarch,
if (fieldsize < register_size (target_gdbarch (),
reg->regnum))
warning (_("Remote reply is too short: %s"), buf);
@ -5604,7 +5604,7 @@ process_stop_reply (struct stop_reply *stop_reply,
if (stop_reply->regcache)
{
struct regcache *regcache
= get_thread_arch_regcache (ptid, target_gdbarch);
= get_thread_arch_regcache (ptid, target_gdbarch ());
cached_reg_t *reg;
int ix;
@ -6318,7 +6318,7 @@ remote_address_masked (CORE_ADDR addr)
/* If "remoteaddresssize" was not set, default to target address size. */
if (!address_size)
address_size = gdbarch_addr_bit (target_gdbarch);
address_size = gdbarch_addr_bit (target_gdbarch ());
if (address_size > 0
&& address_size < (sizeof (ULONGEST) * 8))
@ -6854,7 +6854,7 @@ static void
remote_flash_erase (struct target_ops *ops,
ULONGEST address, LONGEST length)
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
int saved_remote_timeout = remote_timeout;
enum packet_result ret;
struct cleanup *back_to = make_cleanup (restore_remote_timeout,
@ -8378,12 +8378,12 @@ compare_sections_command (char *args, int from_tty)
if (res == -1)
error (_("target memory fault, section %s, range %s -- %s"), sectname,
paddress (target_gdbarch, lma),
paddress (target_gdbarch, lma + size));
paddress (target_gdbarch (), lma),
paddress (target_gdbarch (), lma + size));
printf_filtered ("Section %s, range %s -- %s: ", sectname,
paddress (target_gdbarch, lma),
paddress (target_gdbarch, lma + size));
paddress (target_gdbarch (), lma),
paddress (target_gdbarch (), lma + size));
if (res)
printf_filtered ("matched.\n");
else
@ -8739,7 +8739,7 @@ remote_search_memory (struct target_ops* ops,
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
struct remote_state *rs = get_remote_state ();
int max_size = get_memory_write_packet_size ();
struct packet_config *packet =
@ -9273,7 +9273,7 @@ static int
remote_read_description_p (struct target_ops *target)
{
struct remote_g_packet_data *data
= gdbarch_data (target_gdbarch, remote_g_packet_data_handle);
= gdbarch_data (target_gdbarch (), remote_g_packet_data_handle);
if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
return 1;
@ -9285,7 +9285,7 @@ static const struct target_desc *
remote_read_description (struct target_ops *target)
{
struct remote_g_packet_data *data
= gdbarch_data (target_gdbarch, remote_g_packet_data_handle);
= gdbarch_data (target_gdbarch (), remote_g_packet_data_handle);
/* Do not try this during initial connection, when we do not know
whether there is a running but stopped thread. */
@ -10279,7 +10279,7 @@ remote_download_tracepoint (struct bp_location *loc)
{
int isize;
if (gdbarch_fast_tracepoint_valid_at (target_gdbarch,
if (gdbarch_fast_tracepoint_valid_at (target_gdbarch (),
tpaddr, &isize, NULL))
xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":F%x",
isize);

4
gdb/rl78-tdep.c
View File

@ -616,7 +616,7 @@ check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size,
if (value.kind == pvk_register
&& value.k == 0
&& pv_is_register (addr, RL78_SP_REGNUM)
&& size == register_size (target_gdbarch, value.reg))
&& size == register_size (target_gdbarch (), value.reg))
result->reg_offset[value.reg] = addr.k;
}
@ -643,7 +643,7 @@ rl78_analyze_prologue (CORE_ADDR start_pc,
result->reg_offset[rn] = 1;
}
stack = make_pv_area (RL78_SP_REGNUM, gdbarch_addr_bit (target_gdbarch));
stack = make_pv_area (RL78_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ()));
back_to = make_cleanup_free_pv_area (stack);
/* The call instruction has saved the return address on the stack. */

2
gdb/rs6000-nat.c
View File

@ -76,7 +76,7 @@
#ifndef ARCH3264
# define ARCH64() 0
#else
# define ARCH64() (register_size (target_gdbarch, 0) == 8)
# define ARCH64() (register_size (target_gdbarch (), 0) == 8)
#endif
/* Union of 32-bit and 64-bit versions of ld_info. */

4
gdb/rx-tdep.c
View File

@ -154,7 +154,7 @@ check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
if (value.kind == pvk_register
&& value.k == 0
&& pv_is_register (addr, RX_SP_REGNUM)
&& size == register_size (target_gdbarch, value.reg))
&& size == register_size (target_gdbarch (), value.reg))
result->reg_offset[value.reg] = addr.k;
}
@ -207,7 +207,7 @@ rx_analyze_prologue (CORE_ADDR start_pc,
result->reg_offset[rn] = 1;
}
stack = make_pv_area (RX_SP_REGNUM, gdbarch_addr_bit (target_gdbarch));
stack = make_pv_area (RX_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ()));
back_to = make_cleanup_free_pv_area (stack);
/* The call instruction has saved the return address on the stack. */

2
gdb/s390-nat.c
View File

@ -601,7 +601,7 @@ s390_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
{
int sizeof_auxv_field = s390_target_wordsize ();
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte *ptr = *readptr;
if (endptr == ptr)

12
gdb/sol-thread.c
View File

@ -861,7 +861,7 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
target_fetch_registers (regcache, -1);
fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
@ -883,7 +883,7 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
supply_gregset (regcache, (const gdb_gregset_t *) gregset);
target_store_registers (regcache, -1);
@ -917,7 +917,7 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
target_fetch_registers (regcache, -1);
fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
@ -939,7 +939,7 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
old_chain = save_inferior_ptid ();
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
target_store_registers (regcache, -1);
@ -1119,7 +1119,7 @@ info_cb (const td_thrhandle_t *th, void *s)
SYMBOL_PRINT_NAME (msym));
else
printf_filtered (" startfunc: %s\n",
paddress (target_gdbarch, ti.ti_startfunc));
paddress (target_gdbarch (), ti.ti_startfunc));
}
/* If thread is asleep, print function that went to sleep. */
@ -1132,7 +1132,7 @@ info_cb (const td_thrhandle_t *th, void *s)
SYMBOL_PRINT_NAME (msym));
else
printf_filtered (" - Sleep func: %s\n",
paddress (target_gdbarch, ti.ti_startfunc));
paddress (target_gdbarch (), ti.ti_startfunc));
}
/* Wrap up line, if necessary. */

16
gdb/solib-darwin.c
View File

@ -127,8 +127,8 @@ static void
darwin_load_image_infos (struct darwin_info *info)
{
gdb_byte buf[24];
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
int len;
/* If the structure address is not known, don't continue. */
@ -245,8 +245,8 @@ open_symbol_file_object (void *from_ttyp)
static struct so_list *
darwin_current_sos (void)
{
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int ptr_len = TYPE_LENGTH (ptr_type);
unsigned int image_info_size;
struct so_list *head = NULL;
@ -378,7 +378,7 @@ darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
make_cleanup_bfd_unref (dyld_bfd);
sub = bfd_mach_o_fat_extract (dyld_bfd, bfd_object,
gdbarch_bfd_arch_info (target_gdbarch));
gdbarch_bfd_arch_info (target_gdbarch ()));
if (sub)
{
dyld_bfd = sub;
@ -420,7 +420,7 @@ darwin_solib_read_all_image_info_addr (struct darwin_info *info)
{
gdb_byte buf[8 + 8 + 4];
LONGEST len;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
len = target_read (&current_target, TARGET_OBJECT_DARWIN_DYLD_INFO, NULL,
buf, 0, sizeof (buf));
@ -450,7 +450,7 @@ darwin_solib_create_inferior_hook (int from_tty)
darwin_load_image_infos (info);
if (darwin_dyld_version_ok (info))
create_solib_event_breakpoint (target_gdbarch, info->all_image.notifier);
create_solib_event_breakpoint (target_gdbarch (), info->all_image.notifier);
}
static void
@ -515,7 +515,7 @@ darwin_bfd_open (char *pathname)
abfd = solib_bfd_fopen (found_pathname, found_file);
res = bfd_mach_o_fat_extract (abfd, bfd_object,
gdbarch_bfd_arch_info (target_gdbarch));
gdbarch_bfd_arch_info (target_gdbarch ()));
if (!res)
{
make_cleanup_bfd_unref (abfd);

24
gdb/solib-dsbt.c
View File

@ -212,13 +212,13 @@ dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map)
for (i = 0; i < map->nsegs; i++)
printf_filtered ("%s:%s -> %s:%s\n",
print_core_address (target_gdbarch,
print_core_address (target_gdbarch (),
map->segs[i].p_vaddr),
print_core_address (target_gdbarch,
print_core_address (target_gdbarch (),
map->segs[i].p_vaddr
+ map->segs[i].p_memsz),
print_core_address (target_gdbarch, map->segs[i].addr),
print_core_address (target_gdbarch, map->segs[i].addr
print_core_address (target_gdbarch (), map->segs[i].addr),
print_core_address (target_gdbarch (), map->segs[i].addr
+ map->segs[i].p_memsz));
}
}
@ -228,7 +228,7 @@ dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map)
static struct int_elf32_dsbt_loadmap *
decode_loadmap (gdb_byte *buf)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
struct int_elf32_dsbt_loadmap *int_ldmbuf;
@ -327,7 +327,7 @@ dsbt_get_initial_loadmaps (void)
static struct int_elf32_dsbt_loadmap *
fetch_loadmap (CORE_ADDR ldmaddr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial;
struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
struct int_elf32_dsbt_loadmap *int_ldmbuf;
@ -496,7 +496,7 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
gdb_byte ptr_buf[8];
CORE_ADDR ptr_addr;
ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
@ -555,7 +555,7 @@ displacement_from_map (struct int_elf32_dsbt_loadmap *map,
static CORE_ADDR
lm_base (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct minimal_symbol *got_sym;
CORE_ADDR addr;
gdb_byte buf[TIC6X_PTR_SIZE];
@ -635,7 +635,7 @@ lm_base (void)
static struct so_list *
dsbt_current_sos (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR lm_addr;
struct so_list *sos_head = NULL;
struct so_list **sos_next_ptr = &sos_head;
@ -814,7 +814,7 @@ cmp_name (asymbol *sym, void *data)
static int
enable_break2 (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int success = 0;
char **bkpt_namep;
asection *interp_sect;
@ -965,7 +965,7 @@ enable_break2 (void)
remove_solib_event_breakpoints ();
/* Now (finally!) create the solib breakpoint. */
create_solib_event_breakpoint (target_gdbarch, addr);
create_solib_event_breakpoint (target_gdbarch (), addr);
info->enable_break2_done = 1;
@ -1007,7 +1007,7 @@ enable_break (void)
return 0;
}
create_solib_event_breakpoint (target_gdbarch,
create_solib_event_breakpoint (target_gdbarch (),
SYMBOL_VALUE_ADDRESS (start));
if (solib_dsbt_debug)

18
gdb/solib-frv.c
View File

@ -98,7 +98,7 @@ struct int_elf32_fdpic_loadmap {
static struct int_elf32_fdpic_loadmap *
fetch_loadmap (CORE_ADDR ldmaddr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct ext_elf32_fdpic_loadmap ext_ldmbuf_partial;
struct ext_elf32_fdpic_loadmap *ext_ldmbuf;
struct int_elf32_fdpic_loadmap *int_ldmbuf;
@ -265,7 +265,7 @@ static CORE_ADDR main_lm_addr = 0;
static CORE_ADDR
lm_base (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct minimal_symbol *got_sym;
CORE_ADDR addr;
gdb_byte buf[FRV_PTR_SIZE];
@ -317,7 +317,7 @@ lm_base (void)
static struct so_list *
frv_current_sos (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR lm_addr, mgot;
struct so_list *sos_head = NULL;
struct so_list **sos_next_ptr = &sos_head;
@ -518,7 +518,7 @@ static int enable_break2_done = 0;
static int
enable_break2 (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int success = 0;
char **bkpt_namep;
asection *interp_sect;
@ -569,7 +569,7 @@ enable_break2 (void)
return 0;
}
status = frv_fdpic_loadmap_addresses (target_gdbarch,
status = frv_fdpic_loadmap_addresses (target_gdbarch (),
&interp_loadmap_addr, 0);
if (status < 0)
{
@ -703,7 +703,7 @@ enable_break2 (void)
remove_solib_event_breakpoints ();
/* Now (finally!) create the solib breakpoint. */
create_solib_event_breakpoint (target_gdbarch, addr);
create_solib_event_breakpoint (target_gdbarch (), addr);
enable_break2_done = 1;
@ -751,7 +751,7 @@ enable_break (void)
return 0;
}
create_solib_event_breakpoint (target_gdbarch,
create_solib_event_breakpoint (target_gdbarch (),
symfile_objfile->ei.entry_point);
if (solib_frv_debug)
@ -782,7 +782,7 @@ frv_relocate_main_executable (void)
int changed;
struct obj_section *osect;
status = frv_fdpic_loadmap_addresses (target_gdbarch,
status = frv_fdpic_loadmap_addresses (target_gdbarch (),
&interp_addr, &exec_addr);
if (status < 0 || (exec_addr == 0 && interp_addr == 0))
@ -1021,7 +1021,7 @@ find_canonical_descriptor_in_load_object
(CORE_ADDR entry_point, CORE_ADDR got_value, const char *name, bfd *abfd,
struct lm_info *lm)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
arelent *rel;
unsigned int i;
CORE_ADDR addr = 0;

2
gdb/solib-ia64-hpux.c
View File

@ -396,7 +396,7 @@ ia64_hpux_clear_solib (void)
static CORE_ADDR
ia64_hpux_get_load_info_addr (void)
{
struct type *data_ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *data_ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
CORE_ADDR addr;
int status;

14
gdb/solib-irix.c
View File

@ -142,7 +142,7 @@ extract_mips_address (void *addr, int len, enum bfd_endian byte_order)
static struct lm_info
fetch_lm_info (CORE_ADDR addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct lm_info li;
union irix_obj_info buf;
@ -306,7 +306,7 @@ disable_break (void)
/* Note that breakpoint address and original contents are in our address
space, so we just need to write the original contents back. */
if (deprecated_remove_raw_breakpoint (target_gdbarch, base_breakpoint) != 0)
if (deprecated_remove_raw_breakpoint (target_gdbarch (), base_breakpoint) != 0)
{
status = 0;
}
@ -339,7 +339,7 @@ enable_break (void)
if (!entry_point_address_query (&entry_point))
return 0;
base_breakpoint = deprecated_insert_raw_breakpoint (target_gdbarch,
base_breakpoint = deprecated_insert_raw_breakpoint (target_gdbarch (),
aspace, entry_point);
if (base_breakpoint != NULL)
@ -453,8 +453,8 @@ irix_solib_create_inferior_hook (int from_tty)
static struct so_list *
irix_current_sos (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
int addr_size = gdbarch_addr_bit (target_gdbarch) / TARGET_CHAR_BIT;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / TARGET_CHAR_BIT;
CORE_ADDR lma;
char addr_buf[8];
struct so_list *head = 0;
@ -545,8 +545,8 @@ irix_current_sos (void)
static int
irix_open_symbol_file_object (void *from_ttyp)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
int addr_size = gdbarch_addr_bit (target_gdbarch) / TARGET_CHAR_BIT;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / TARGET_CHAR_BIT;
CORE_ADDR lma;
char addr_buf[8];
struct lm_info lm;

2
gdb/solib-pa64.c
View File

@ -391,7 +391,7 @@ manpage for methods to privately map shared library text."));
/* Create the shared library breakpoint. */
{
struct breakpoint *b
= create_solib_event_breakpoint (target_gdbarch, sym_addr);
= create_solib_event_breakpoint (target_gdbarch (), sym_addr);
/* The breakpoint is actually hard-coded into the dynamic linker,
so we don't need to actually insert a breakpoint instruction

30
gdb/solib-som.c
View File

@ -185,7 +185,7 @@ struct {
static void
som_solib_create_inferior_hook (int from_tty)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct minimal_symbol *msymbol;
unsigned int dld_flags, status, have_endo;
asection *shlib_info;
@ -288,7 +288,7 @@ Suggest linking with /opt/langtools/lib/end.o.\n\
GDB will be unable to track shl_load/shl_unload calls"));
goto keep_going;
}
create_solib_event_breakpoint (target_gdbarch,
create_solib_event_breakpoint (target_gdbarch (),
SYMBOL_VALUE_ADDRESS (msymbol));
/* We have all the support usually found in end.o, so we can track
@ -353,7 +353,7 @@ manpage for methods to privately map shared library text."));
anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
/* Make the breakpoint at "_start" a shared library event breakpoint. */
create_solib_event_breakpoint (target_gdbarch, anaddr);
create_solib_event_breakpoint (target_gdbarch (), anaddr);
clear_symtab_users (0);
}
@ -525,7 +525,7 @@ struct dld_list {
static CORE_ADDR
link_map_start (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct minimal_symbol *sym;
CORE_ADDR addr;
char buf[4];
@ -575,7 +575,7 @@ match_main (const char *name)
static struct so_list *
som_current_sos (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR lm;
struct so_list *head = 0;
struct so_list **link_ptr = &head;
@ -642,27 +642,27 @@ som_current_sos (void)
#ifdef SOLIB_SOM_DBG
printf ("\n+ library \"%s\" is described at %s\n", new->so_name,
paddress (target_gdbarch, lm));
paddress (target_gdbarch (), lm));
printf (" 'version' is %d\n", new->lm_info->struct_version);
printf (" 'bind_mode' is %d\n", new->lm_info->bind_mode);
printf (" 'library_version' is %d\n",
new->lm_info->library_version);
printf (" 'text_addr' is %s\n",
paddress (target_gdbarch, new->lm_info->text_addr));
paddress (target_gdbarch (), new->lm_info->text_addr));
printf (" 'text_link_addr' is %s\n",
paddress (target_gdbarch, new->lm_info->text_link_addr));
paddress (target_gdbarch (), new->lm_info->text_link_addr));
printf (" 'text_end' is %s\n",
paddress (target_gdbarch, new->lm_info->text_end));
paddress (target_gdbarch (), new->lm_info->text_end));
printf (" 'data_start' is %s\n",
paddress (target_gdbarch, new->lm_info->data_start));
paddress (target_gdbarch (), new->lm_info->data_start));
printf (" 'bss_start' is %s\n",
paddress (target_gdbarch, new->lm_info->bss_start));
paddress (target_gdbarch (), new->lm_info->bss_start));
printf (" 'data_end' is %s\n",
paddress (target_gdbarch, new->lm_info->data_end));
paddress (target_gdbarch (), new->lm_info->data_end));
printf (" 'got_value' is %s\n",
paddress (target_gdbarch, new->lm_info->got_value));
paddress (target_gdbarch (), new->lm_info->got_value));
printf (" 'tsd_start_addr' is %s\n",
paddress (target_gdbarch, new->lm_info->tsd_start_addr));
paddress (target_gdbarch (), new->lm_info->tsd_start_addr));
#endif
new->addr_low = lmi->text_addr;
@ -692,7 +692,7 @@ som_current_sos (void)
static int
som_open_symbol_file_object (void *from_ttyp)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR lm, l_name;
char *filename;
int errcode;

6
gdb/solib-spu.c
View File

@ -158,7 +158,7 @@ append_ocl_sos (struct so_list **link_ptr)
static struct so_list *
spu_current_sos (void)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct so_list *head;
struct so_list **link_ptr;
@ -418,9 +418,9 @@ spu_enable_break (struct objfile *objfile)
{
CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (spe_event_sym);
addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch, addr,
addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), addr,
&current_target);
create_solib_event_breakpoint (target_gdbarch, addr);
create_solib_event_breakpoint (target_gdbarch (), addr);
return 1;
}

12
gdb/solib-sunos.c
View File

@ -121,7 +121,7 @@ static char *main_name_list[] =
#define SOLIB_EXTRACT_ADDRESS(MEMBER) \
extract_unsigned_integer (&(MEMBER), sizeof (MEMBER), \
gdbarch_byte_order (target_gdbarch))
gdbarch_byte_order (target_gdbarch ()))
/* local data declarations */
@ -141,7 +141,7 @@ static CORE_ADDR flag_addr;
static CORE_ADDR
lm_addr (struct so_list *so)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int lm_addr_offset = offsetof (struct link_map, lm_addr);
int lm_addr_size = fieldsize (struct link_map, lm_addr);
@ -152,7 +152,7 @@ lm_addr (struct so_list *so)
static CORE_ADDR
lm_next (struct so_list *so)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int lm_next_offset = offsetof (struct link_map, lm_next);
int lm_next_size = fieldsize (struct link_map, lm_next);
@ -164,7 +164,7 @@ lm_next (struct so_list *so)
static CORE_ADDR
lm_name (struct so_list *so)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int lm_name_offset = offsetof (struct link_map, lm_name);
int lm_name_size = fieldsize (struct link_map, lm_name);
@ -690,9 +690,9 @@ sunos_solib_create_inferior_hook (int from_tty)
the GDB software break point list. Thus we have to adjust the
PC here. */
if (gdbarch_decr_pc_after_break (target_gdbarch))
if (gdbarch_decr_pc_after_break (target_gdbarch ()))
{
stop_pc -= gdbarch_decr_pc_after_break (target_gdbarch);
stop_pc -= gdbarch_decr_pc_after_break (target_gdbarch ());
regcache_write_pc (get_current_regcache (), stop_pc);
}

62
gdb/solib-svr4.c
View File

@ -155,12 +155,12 @@ lm_info_read (CORE_ADDR lm_addr)
if (target_read_memory (lm_addr, lm, lmo->link_map_size) != 0)
{
warning (_("Error reading shared library list entry at %s"),
paddress (target_gdbarch, lm_addr)),
paddress (target_gdbarch (), lm_addr)),
lm_info = NULL;
}
else
{
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
lm_info = xzalloc (sizeof (*lm_info));
lm_info->lm_addr = lm_addr;
@ -264,7 +264,7 @@ lm_addr_check (struct so_list *so, bfd *abfd)
if (info_verbose)
printf_unfiltered (_("Using PIC (Position Independent Code) "
"prelink displacement %s for \"%s\".\n"),
paddress (target_gdbarch, l_addr),
paddress (target_gdbarch (), l_addr),
so->so_name);
}
else
@ -363,7 +363,7 @@ static int match_main (const char *);
static gdb_byte *
read_program_header (int type, int *p_sect_size, int *p_arch_size)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
int arch_size, sect_size;
CORE_ADDR sect_addr;
@ -612,7 +612,7 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
gdb_byte ptr_buf[8];
CORE_ADDR ptr_addr;
ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
@ -632,7 +632,7 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
static int
scan_dyntag_auxv (int dyntag, CORE_ADDR *ptr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
int sect_size, arch_size, step;
long dyn_tag;
CORE_ADDR dyn_ptr;
@ -709,7 +709,7 @@ elf_locate_base (void)
if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr)
|| scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr))
{
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
gdb_byte *pbuf;
int pbuf_size = TYPE_LENGTH (ptr_type);
@ -787,7 +787,7 @@ static CORE_ADDR
solib_svr4_r_map (struct svr4_info *info)
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
CORE_ADDR addr = 0;
volatile struct gdb_exception ex;
@ -806,7 +806,7 @@ static CORE_ADDR
solib_svr4_r_brk (struct svr4_info *info)
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
return read_memory_typed_address (info->debug_base + lmo->r_brk_offset,
ptr_type);
@ -819,8 +819,8 @@ static CORE_ADDR
solib_svr4_r_ldsomap (struct svr4_info *info)
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
ULONGEST version;
/* Check version, and return zero if `struct r_debug' doesn't have
@ -889,7 +889,7 @@ open_symbol_file_object (void *from_ttyp)
int errcode;
int from_tty = *(int *)from_ttyp;
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
int l_name_size = TYPE_LENGTH (ptr_type);
gdb_byte *l_name_buf = xmalloc (l_name_size);
struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
@ -1197,8 +1197,8 @@ svr4_read_so_list (CORE_ADDR lm, struct so_list ***link_ptr_ptr,
if (new->lm_info->l_prev != prev_lm)
{
warning (_("Corrupted shared library list: %s != %s"),
paddress (target_gdbarch, prev_lm),
paddress (target_gdbarch, new->lm_info->l_prev));
paddress (target_gdbarch (), prev_lm),
paddress (target_gdbarch (), new->lm_info->l_prev));
do_cleanups (old_chain);
break;
}
@ -1396,7 +1396,7 @@ exec_entry_point (struct bfd *abfd, struct target_ops *targ)
gdbarch_convert_from_func_ptr_addr(). The method
gdbarch_convert_from_func_ptr_addr() is the merely the identify
function for targets which don't use function descriptors. */
return gdbarch_convert_from_func_ptr_addr (target_gdbarch,
return gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
bfd_get_start_address (abfd),
targ);
}
@ -1468,7 +1468,7 @@ enable_break (struct svr4_info *info, int from_tty)
struct obj_section *os;
sym_addr = gdbarch_addr_bits_remove
(target_gdbarch, gdbarch_convert_from_func_ptr_addr (target_gdbarch,
(target_gdbarch (), gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
sym_addr,
&current_target));
@ -1522,7 +1522,7 @@ enable_break (struct svr4_info *info, int from_tty)
+ bfd_section_size (tmp_bfd, interp_sect);
}
create_solib_event_breakpoint (target_gdbarch, sym_addr);
create_solib_event_breakpoint (target_gdbarch (), sym_addr);
return 1;
}
}
@ -1585,7 +1585,7 @@ enable_break (struct svr4_info *info, int from_tty)
if (!load_addr_found)
if (target_auxv_search (&current_target, AT_BASE, &load_addr) > 0)
{
int addr_bit = gdbarch_addr_bit (target_gdbarch);
int addr_bit = gdbarch_addr_bit (target_gdbarch ());
/* Ensure LOAD_ADDR has proper sign in its possible upper bits so
that `+ load_addr' will overflow CORE_ADDR width not creating
@ -1621,7 +1621,7 @@ enable_break (struct svr4_info *info, int from_tty)
if (!load_addr_found)
{
struct regcache *regcache
= get_thread_arch_regcache (inferior_ptid, target_gdbarch);
= get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
load_addr = (regcache_read_pc (regcache)
- exec_entry_point (tmp_bfd, tmp_bfd_target));
@ -1669,7 +1669,7 @@ enable_break (struct svr4_info *info, int from_tty)
/* Convert 'sym_addr' from a function pointer to an address.
Because we pass tmp_bfd_target instead of the current
target, this will always produce an unrelocated value. */
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
sym_addr,
tmp_bfd_target);
@ -1680,7 +1680,7 @@ enable_break (struct svr4_info *info, int from_tty)
if (sym_addr != 0)
{
create_solib_event_breakpoint (target_gdbarch, load_addr + sym_addr);
create_solib_event_breakpoint (target_gdbarch (), load_addr + sym_addr);
xfree (interp_name);
return 1;
}
@ -1703,10 +1703,10 @@ enable_break (struct svr4_info *info, int from_tty)
if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
{
sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
sym_addr,
&current_target);
create_solib_event_breakpoint (target_gdbarch, sym_addr);
create_solib_event_breakpoint (target_gdbarch (), sym_addr);
return 1;
}
}
@ -1719,10 +1719,10 @@ enable_break (struct svr4_info *info, int from_tty)
if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
{
sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
sym_addr,
&current_target);
create_solib_event_breakpoint (target_gdbarch, sym_addr);
create_solib_event_breakpoint (target_gdbarch (), sym_addr);
return 1;
}
}
@ -1863,7 +1863,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp)
buf2 = read_program_headers_from_bfd (exec_bfd, &phdrs2_size);
if (buf != NULL && buf2 != NULL)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
/* We are dealing with three different addresses. EXEC_BFD
represents current address in on-disk file. target memory content
@ -2118,7 +2118,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp)
printf_unfiltered (_("Using PIE (Position Independent Executable) "
"displacement %s for \"%s\".\n"),
paddress (target_gdbarch, displacement),
paddress (target_gdbarch (), displacement),
bfd_get_filename (exec_bfd));
}
@ -2301,12 +2301,12 @@ svr4_clear_solib (void)
static CORE_ADDR
svr4_truncate_ptr (CORE_ADDR addr)
{
if (gdbarch_ptr_bit (target_gdbarch) == sizeof (CORE_ADDR) * 8)
if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
/* We don't need to truncate anything, and the bit twiddling below
will fail due to overflow problems. */
return addr;
else
return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch)) - 1);
return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
}
@ -2364,7 +2364,7 @@ set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
static struct link_map_offsets *
svr4_fetch_link_map_offsets (void)
{
struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch, solib_svr4_data);
struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
gdb_assert (ops->fetch_link_map_offsets);
return ops->fetch_link_map_offsets ();
@ -2375,7 +2375,7 @@ svr4_fetch_link_map_offsets (void)
static int
svr4_have_link_map_offsets (void)
{
struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch, solib_svr4_data);
struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
return (ops->fetch_link_map_offsets != NULL);
}

28
gdb/solib.c
View File

@ -143,12 +143,12 @@ show_solib_search_path (struct ui_file *file, int from_tty,
char *
solib_find (char *in_pathname, int *fd)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
int found_file = -1;
char *temp_pathname = NULL;
int gdb_sysroot_is_empty;
const char *solib_symbols_extension
= gdbarch_solib_symbols_extension (target_gdbarch);
= gdbarch_solib_symbols_extension (target_gdbarch ());
const char *fskind = effective_target_file_system_kind ();
struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
char *sysroot = NULL;
@ -424,7 +424,7 @@ solib_bfd_open (char *pathname)
}
/* Check bfd arch. */
b = gdbarch_bfd_arch_info (target_gdbarch);
b = gdbarch_bfd_arch_info (target_gdbarch ());
if (!b->compatible (b, bfd_get_arch_info (abfd)))
warning (_("`%s': Shared library architecture %s is not compatible "
"with target architecture %s."), bfd_get_filename (abfd),
@ -448,7 +448,7 @@ solib_bfd_open (char *pathname)
static int
solib_map_sections (struct so_list *so)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
char *filename;
struct target_section *p;
struct cleanup *old_chain;
@ -549,7 +549,7 @@ free_so_symbols (struct so_list *so)
void
free_so (struct so_list *so)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
free_so_symbols (so);
ops->free_so (so);
@ -668,7 +668,7 @@ solib_used (const struct so_list *const known)
static void
update_solib_list (int from_tty, struct target_ops *target)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
struct so_list *inferior = ops->current_sos();
struct so_list *gdb, **gdb_link;
@ -930,7 +930,7 @@ solib_add (char *pattern, int from_tty,
if (loaded_any_symbols)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
/* Getting new symbols may change our opinion about what is
frameless. */
@ -954,7 +954,7 @@ info_sharedlibrary_command (char *pattern, int from_tty)
int addr_width;
int nr_libs;
struct cleanup *table_cleanup;
struct gdbarch *gdbarch = target_gdbarch;
struct gdbarch *gdbarch = target_gdbarch ();
struct ui_out *uiout = current_uiout;
if (pattern)
@ -1103,7 +1103,7 @@ solib_name_from_address (struct program_space *pspace, CORE_ADDR address)
int
solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
if (ops->keep_data_in_core)
return ops->keep_data_in_core (vaddr, size);
@ -1116,7 +1116,7 @@ solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
void
clear_solib (void)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
/* This function is expected to handle ELF shared libraries. It is
also used on Solaris, which can run either ELF or a.out binaries
@ -1164,7 +1164,7 @@ clear_solib (void)
void
solib_create_inferior_hook (int from_tty)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
ops->solib_create_inferior_hook (from_tty);
}
@ -1175,7 +1175,7 @@ solib_create_inferior_hook (int from_tty)
int
in_solib_dynsym_resolve_code (CORE_ADDR pc)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
return ops->in_dynsym_resolve_code (pc);
}
@ -1277,7 +1277,7 @@ reload_shared_libraries (char *ignored, int from_tty,
reload_shared_libraries_1 (from_tty);
ops = solib_ops (target_gdbarch);
ops = solib_ops (target_gdbarch ());
/* Creating inferior hooks here has two purposes. First, if we reload
shared libraries then the address of solib breakpoint we've computed
@ -1344,7 +1344,7 @@ solib_global_lookup (const struct objfile *objfile,
const char *name,
const domain_enum domain)
{
struct target_so_ops *ops = solib_ops (target_gdbarch);
struct target_so_ops *ops = solib_ops (target_gdbarch ());
if (ops->lookup_lib_global_symbol != NULL)
return ops->lookup_lib_global_symbol (objfile, name, domain);

2
gdb/spu-linux-nat.c
View File

@ -206,7 +206,7 @@ store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
static int
parse_spufs_run (int *fd, ULONGEST *addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
gdb_byte buf[4];
ULONGEST pc = fetch_ppc_register (32); /* nip */

10
gdb/spu-multiarch.c
View File

@ -57,19 +57,19 @@ static int spu_nr_solib;
static int
parse_spufs_run (ptid_t ptid, int *fd, CORE_ADDR *addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
struct gdbarch_tdep *tdep;
struct regcache *regcache;
char buf[4];
ULONGEST regval;
/* If we're not on PPU, there's nothing to detect. */
if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_powerpc)
if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_powerpc)
return 0;
/* Get PPU-side registers. */
regcache = get_thread_arch_regcache (ptid, target_gdbarch);
tdep = gdbarch_tdep (target_gdbarch);
regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
tdep = gdbarch_tdep (target_gdbarch ());
/* Fetch instruction preceding current NIP. */
if (target_read_memory (regcache_read_pc (regcache) - 4, buf, 4) != 0)
@ -113,7 +113,7 @@ spu_thread_architecture (struct target_ops *ops, ptid_t ptid)
if (parse_spufs_run (ptid, &spufs_fd, &spufs_addr))
return spu_gdbarch (spufs_fd);
return target_gdbarch;
return target_gdbarch ();
}
/* Override the to_region_ok_for_hw_watchpoint routine. */

4
gdb/spu-tdep.c
View File

@ -1186,7 +1186,7 @@ spu2ppu_sniffer (const struct frame_unwind *self,
CORE_ADDR base, func, backchain;
gdb_byte buf[4];
if (gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_spu)
if (gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_spu)
return 0;
base = get_frame_sp (this_frame);
@ -1217,7 +1217,7 @@ spu2ppu_sniffer (const struct frame_unwind *self,
else
{
struct regcache *regcache;
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
cache->regcache = regcache_dup (regcache);
*this_prologue_cache = cache;
return 1;

2
gdb/symfile-mem.c
View File

@ -220,7 +220,7 @@ add_vsyscall_page (struct target_ops *target, int from_tty)
args.bfd = bfd;
args.sysinfo_ehdr = sysinfo_ehdr;
args.name = xstrprintf ("system-supplied DSO at %s",
paddress (target_gdbarch, sysinfo_ehdr));
paddress (target_gdbarch (), sysinfo_ehdr));
/* Pass zero for FROM_TTY, because the action of loading the
vsyscall DSO was not triggered by the user, even if the user
typed "run" at the TTY. */

8
gdb/symfile.c
View File

@ -1957,7 +1957,7 @@ load_progress (ULONGEST bytes, void *untyped_arg)
this section. */
ui_out_message (current_uiout, 0, "Loading section %s, size %s lma %s\n",
args->section_name, hex_string (args->section_size),
paddress (target_gdbarch, args->lma));
paddress (target_gdbarch (), args->lma));
return;
}
@ -1975,10 +1975,10 @@ load_progress (ULONGEST bytes, void *untyped_arg)
if (target_read_memory (args->lma, check, bytes) != 0)
error (_("Download verify read failed at %s"),
paddress (target_gdbarch, args->lma));
paddress (target_gdbarch (), args->lma));
if (memcmp (args->buffer, check, bytes) != 0)
error (_("Download verify compare failed at %s"),
paddress (target_gdbarch, args->lma));
paddress (target_gdbarch (), args->lma));
do_cleanups (verify_cleanups);
}
totals->data_count += bytes;
@ -2133,7 +2133,7 @@ generic_load (char *args, int from_tty)
entry = bfd_get_start_address (loadfile_bfd);
ui_out_text (uiout, "Start address ");
ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch, entry));
ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch (), entry));
ui_out_text (uiout, ", load size ");
ui_out_field_fmt (uiout, "load-size", "%lu", total_progress.data_count);
ui_out_text (uiout, "\n");

2
gdb/symtab.c
View File

@ -1767,7 +1767,7 @@ lookup_symbol_global (const char *name,
lookup_data.name = name;
lookup_data.domain = domain;
gdbarch_iterate_over_objfiles_in_search_order
(objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch,
(objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
lookup_symbol_global_iterator_cb, &lookup_data, objfile);
return lookup_data.result;

4
gdb/target-descriptions.c
View File

@ -334,7 +334,7 @@ target_find_description (void)
/* The current architecture should not have any target description
specified. It should have been cleared, e.g. when we
disconnected from the previous target. */
gdb_assert (gdbarch_target_desc (target_gdbarch) == NULL);
gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
/* First try to fetch an XML description from the user-specified
file. */
@ -367,7 +367,7 @@ target_find_description (void)
{
struct tdesc_arch_data *data;
data = gdbarch_data (target_gdbarch, tdesc_data);
data = gdbarch_data (target_gdbarch (), tdesc_data);
if (tdesc_has_registers (current_target_desc)
&& data->arch_regs == NULL)
warning (_("Target-supplied registers are not supported "

16
gdb/target.c
View File

@ -1128,7 +1128,7 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
}
if (target != NULL
&& gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
&& gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
{
ptid_t ptid = inferior_ptid;
volatile struct gdb_exception ex;
@ -1138,7 +1138,7 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
CORE_ADDR lm_addr;
/* Fetch the load module address for this objfile. */
lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch,
lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch (),
objfile);
/* If it's 0, throw the appropriate exception. */
if (lm_addr == 0)
@ -2497,7 +2497,7 @@ target_pre_inferior (int from_tty)
/* In some OSs, the shared library list is the same/global/shared
across inferiors. If code is shared between processes, so are
memory regions and features. */
if (!gdbarch_has_global_solist (target_gdbarch))
if (!gdbarch_has_global_solist (target_gdbarch ()))
{
no_shared_libraries (NULL, from_tty);
@ -2566,7 +2566,7 @@ target_detach (char *args, int from_tty)
{
struct target_ops* t;
if (gdbarch_has_global_breakpoints (target_gdbarch))
if (gdbarch_has_global_breakpoints (target_gdbarch ()))
/* Don't remove global breakpoints here. They're removed on
disconnection from the target. */
;
@ -3554,7 +3554,7 @@ target_fileio_read_stralloc (const char *filename)
static int
default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
{
return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
}
static int
@ -3568,7 +3568,7 @@ default_watchpoint_addr_within_range (struct target_ops *target,
static struct gdbarch *
default_thread_architecture (struct target_ops *ops, ptid_t ptid)
{
return target_gdbarch;
return target_gdbarch ();
}
static int
@ -4055,7 +4055,7 @@ target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
"target_verify_memory (%s, %s) = %d\n",
paddress (target_gdbarch, memaddr),
paddress (target_gdbarch (), memaddr),
pulongest (size),
retval);
return retval;
@ -4169,7 +4169,7 @@ deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
fprintf_unfiltered (gdb_stdlog,
"target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
paddress (target_gdbarch, memaddr), len,
paddress (target_gdbarch (), memaddr), len,
write ? "write" : "read", retval);
if (retval > 0)

4
gdb/target.h
View File

@ -687,9 +687,9 @@ struct target_ops
to_thread_architecture would return SPU, otherwise PPC32 or PPC64).
This is architecture used to perform decr_pc_after_break adjustment,
and also determines the frame architecture of the innermost frame.
ptrace operations need to operate according to target_gdbarch.
ptrace operations need to operate according to target_gdbarch ().
The default implementation always returns target_gdbarch. */
The default implementation always returns target_gdbarch (). */
struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t);
/* Determine current address space of thread PTID.

18
gdb/tracepoint.c
View File

@ -4206,7 +4206,7 @@ tfile_get_traceframe_address (off_t tframe_offset)
tfile_read ((gdb_byte *) &tpnum, 2);
tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
gdbarch_byte_order
(target_gdbarch));
(target_gdbarch ()));
tp = get_tracepoint_by_number_on_target (tpnum);
/* FIXME this is a poor heuristic if multiple locations. */
@ -4250,14 +4250,14 @@ tfile_trace_find (enum trace_find_type type, int num,
tfile_read ((gdb_byte *) &tpnum, 2);
tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
gdbarch_byte_order
(target_gdbarch));
(target_gdbarch ()));
offset += 2;
if (tpnum == 0)
break;
tfile_read ((gdb_byte *) &data_size, 4);
data_size = (unsigned int) extract_unsigned_integer
((gdb_byte *) &data_size, 4,
gdbarch_byte_order (target_gdbarch));
gdbarch_byte_order (target_gdbarch ()));
offset += 4;
switch (type)
{
@ -4365,7 +4365,7 @@ traceframe_walk_blocks (walk_blocks_callback_func callback,
mlen = (unsigned short)
extract_unsigned_integer ((gdb_byte *) &mlen, 2,
gdbarch_byte_order
(target_gdbarch));
(target_gdbarch ()));
lseek (trace_fd, mlen, SEEK_CUR);
pos += (8 + 2 + mlen);
break;
@ -4502,7 +4502,7 @@ tfile_xfer_partial (struct target_ops *ops, enum target_object object,
{
ULONGEST maddr, amt;
unsigned short mlen;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
tfile_read ((gdb_byte *) &maddr, 8);
maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
@ -4585,13 +4585,13 @@ tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
tfile_read ((gdb_byte *) &vnum, 4);
vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
gdbarch_byte_order
(target_gdbarch));
(target_gdbarch ()));
if (tsvnum == vnum)
{
tfile_read ((gdb_byte *) val, 8);
*val = extract_signed_integer ((gdb_byte *) val, 8,
gdbarch_byte_order
(target_gdbarch));
(target_gdbarch ()));
return 1;
}
pos += (4 + 8);
@ -4739,7 +4739,7 @@ parse_static_tracepoint_marker_definition (char *line, char **pp,
p = unpack_varlen_hex (p, &addr);
p++; /* skip a colon */
marker->gdbarch = target_gdbarch;
marker->gdbarch = target_gdbarch ();
marker->address = (CORE_ADDR) addr;
endp = strchr (p, ':');
@ -4916,7 +4916,7 @@ info_static_tracepoint_markers_command (char *arg, int from_tty)
ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
if (gdbarch_addr_bit (target_gdbarch) <= 32)
if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
else
ui_out_table_header (uiout, 18, ui_left, "addr", "Address");

2
gdb/windows-nat.c
View File

@ -2404,7 +2404,7 @@ windows_xfer_shared_libraries (struct target_ops *ops,
for (so = solib_start.next; so; so = so->next)
windows_xfer_shared_library (so->so_name, (CORE_ADDR)
(uintptr_t) so->lm_info->load_addr,
target_gdbarch, &obstack);
target_gdbarch (), &obstack);
obstack_grow_str0 (&obstack, "</library-list>\n");
buf = obstack_finish (&obstack);

8
gdb/windows-tdep.c
View File

@ -290,8 +290,8 @@ display_one_tib (ptid_t ptid)
gdb_byte *index;
CORE_ADDR thread_local_base;
ULONGEST i, val, max, max_name, size, tib_size;
ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch ());
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
if (sizeof_ptr == 64)
{
@ -329,13 +329,13 @@ display_one_tib (ptid_t ptid)
printf_filtered (_("Unable to read thread information "
"block for %s at address %s\n"),
target_pid_to_str (ptid),
paddress (target_gdbarch, thread_local_base));
paddress (target_gdbarch (), thread_local_base));
return -1;
}
printf_filtered (_("Thread Information Block %s at %s\n"),
target_pid_to_str (ptid),
paddress (target_gdbarch, thread_local_base));
paddress (target_gdbarch (), thread_local_base));
index = (gdb_byte *) tib;

2
gdb/xcoffsolib.c
View File

@ -62,7 +62,7 @@ static void sharedlibrary_command (char *pattern, int from_tty);
static void
solib_info (char *args, int from_tty)
{
int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
struct vmap *vp = vmap;
/* Check for new shared libraries loaded with load (). */