Re: [PATCH] Multi-process + multi-arch: GDB

Tom Tromey
2012-11-09T19:08:33Z

>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:

Pedro> I tried to follow the get_current_arch() precedent (was originally
Pedro> current_gdbarch). Looking again, I messed up a bit, as get_target_arch()
Pedro> would be even more in spirit.

Pedro> But anyway is fine with me. You choose. ;-)

I picked 'target_gdbarch ()' just due to the long history of using this
name.

Here's the patch, let me know what you think. I made most of it with
'perl -pi'. I only touched gdbarch.sh by hand.

Tested by rebuilding. I use --enable-targets=all, so it has pretty good
coverage of all the changes.

Note the short-ish ChangeLog. I could perhaps write a more detailed
one, but in this case it hardly seemed worthwhile.

Finally, I wonder whether deprecated_target_gdbarch_select_hack should
be un-deprecated. The comment says:

/* Helper function. Set the global "target_gdbarch" to "gdbarch".

FIXME: kettenis/20031124: Of the functions that follow, only
gdbarch_from_bfd is supposed to survive. The others will
dissappear since in the future GDB will (hopefully) be truly
multi-arch. However, for now we're still stuck with the concept of
a single active architecture. */

It seems to me that we have settled on a somewhat different design; but
also that the badness indicated by this comment no longer exists.

Tom

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.

diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c
index 0e441fb..02ac6d0 100644
--- a/gdb/ada-tasks.c
+++ b/gdb/ada-tasks.c
@@ -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')
diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index c7d73eb..5da6c4e 100644
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -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. */
diff --git a/gdb/amd64-linux-nat.c b/gdb/amd64-linux-nat.c
index 01982ac..f4a12db 100644
--- a/gdb/amd64-linux-nat.c
+++ b/gdb/amd64-linux-nat.c
@@ -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
diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index f4414b9..71d17cf 100644
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -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
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index fbc2479..1a67366 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -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 "
diff --git a/gdb/auxv.c b/gdb/auxv.c
index 62628c6..e2aeb21 100644
--- a/gdb/auxv.c
+++ b/gdb/auxv.c
@@ -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");
}
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 3763a04..d47544b 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -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 ();
diff --git a/gdb/bsd-uthread.c b/gdb/bsd-uthread.c
index 948af8f..fed14d5 100644
--- a/gdb/bsd-uthread.c
+++ b/gdb/bsd-uthread.c
@@ -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)
diff --git a/gdb/cli/cli-dump.c b/gdb/cli/cli-dump.c
index dd9c3b8..c2d1397 100644
--- a/gdb/cli/cli-dump.c
+++ b/gdb/cli/cli-dump.c
@@ -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
diff --git a/gdb/common/agent.c b/gdb/common/agent.c
index 43f1b65..156b154 100644
--- a/gdb/common/agent.c
+++ b/gdb/common/agent.c
@@ -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,
diff --git a/gdb/corefile.c b/gdb/corefile.c
index a2ed24f..78dbbc2 100644
--- a/gdb/corefile.c
+++ b/gdb/corefile.c
@@ -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));
}

diff --git a/gdb/darwin-nat-info.c b/gdb/darwin-nat-info.c
index 9741538..67e73e6 100644
--- a/gdb/darwin-nat-info.c
+++ b/gdb/darwin-nat-info.c
@@ -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",
diff --git a/gdb/dcache.c b/gdb/dcache.c
index 652cfab..ce9fe31 100644
--- a/gdb/dcache.c
+++ b/gdb/dcache.c
@@ -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;

diff --git a/gdb/dsrec.c b/gdb/dsrec.c
index 20ff339..9ea23c0 100644
--- a/gdb/dsrec.c
+++ b/gdb/dsrec.c
@@ -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. */
diff --git a/gdb/exec.c b/gdb/exec.c
index 2bd3181..615d5c0 100644
--- a/gdb/exec.c
+++ b/gdb/exec.c
@@ -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);
diff --git a/gdb/fbsd-nat.c b/gdb/fbsd-nat.c
index 4a8a509..254a01a 100644
--- a/gdb/fbsd-nat.c
+++ b/gdb/fbsd-nat.c
@@ -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' : '-');
diff --git a/gdb/filesystem.c b/gdb/filesystem.c
index d855b75..5b4b0cf 100644
--- a/gdb/filesystem.c
+++ b/gdb/filesystem.c
@@ -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;
diff --git a/gdb/gcore.c b/gdb/gcore.c
index 3c8e2f4..5667982 100644
--- a/gdb/gcore.c
+++ b/gdb/gcore.c
@@ -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)
diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 25e4750..26dd404 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -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;
}
diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index 5afb3db..9d2bac3 100644
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -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). */
diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index 13d5cc6..53a52b1 100755
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -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;
}
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index b34935e..e6836d7 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -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);
diff --git a/gdb/i386-darwin-nat.c b/gdb/i386-darwin-nat.c
index 6afbbd0..4680d94 100644
--- a/gdb/i386-darwin-nat.c
+++ b/gdb/i386-darwin-nat.c
@@ -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)];

diff --git a/gdb/i386-nat.c b/gdb/i386-nat.c
index 559bc29..1d4d620 100644
--- a/gdb/i386-nat.c
+++ b/gdb/i386-nat.c
@@ -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);
diff --git a/gdb/ia64-vms-tdep.c b/gdb/ia64-vms-tdep.c
index 09238fc..9f477df 100644
--- a/gdb/ia64-vms-tdep.c
+++ b/gdb/ia64-vms-tdep.c
@@ -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];
diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c
index e6729ac..740798f 100644
--- a/gdb/inf-ptrace.c
+++ b/gdb/inf-ptrace.c
@@ -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)
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index fd035df..c3e602b 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -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
diff --git a/gdb/jit.c b/gdb/jit.c
index 9e8f295..2dcafbc 100644
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -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 ());
}

diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index c282e5d..45f7e24 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -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;
diff --git a/gdb/linux-tdep.c b/gdb/linux-tdep.c
index f02d510..dbeed36 100644
--- a/gdb/linux-tdep.c
+++ b/gdb/linux-tdep.c
@@ -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;

diff --git a/gdb/linux-thread-db.c b/gdb/linux-thread-db.c
index bd90527..c52ab15 100644
--- a/gdb/linux-thread-db.c
+++ b/gdb/linux-thread-db.c
@@ -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;
}
diff --git a/gdb/m32r-rom.c b/gdb/m32r-rom.c
index 4bb4ceb..f74cfe3 100644
--- a/gdb/m32r-rom.c
+++ b/gdb/m32r-rom.c
@@ -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);
diff --git a/gdb/memattr.c b/gdb/memattr.c
index bd92f1d..39c9b22 100644
--- a/gdb/memattr.c
+++ b/gdb/memattr.c
@@ -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";
diff --git a/gdb/mep-tdep.c b/gdb/mep-tdep.c
index c73d38f..7d00445 100644
--- a/gdb/mep-tdep.c
+++ b/gdb/mep-tdep.c
@@ -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;
}

diff --git a/gdb/mi/mi-interp.c b/gdb/mi/mi-interp.c
index d3c3d81..993f8b0 100644
--- a/gdb/mi/mi-interp.c
+++ b/gdb/mi/mi-interp.c
@@ -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
diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c
index 9658400..7427912 100644
--- a/gdb/microblaze-tdep.c
+++ b/gdb/microblaze-tdep.c
@@ -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. */
diff --git a/gdb/mips-linux-nat.c b/gdb/mips-linux-nat.c
index b9f7f1d..bfcd061 100644
--- a/gdb/mips-linux-nat.c
+++ b/gdb/mips-linux-nat.c
@@ -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)));
}

diff --git a/gdb/mips-linux-tdep.c b/gdb/mips-linux-tdep.c
index 272e8d9..023290f 100644
--- a/gdb/mips-linux-tdep.c
+++ b/gdb/mips-linux-tdep.c
@@ -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);

diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index 2af4c89..61f2cd2 100644
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -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)
diff --git a/gdb/monitor.c b/gdb/monitor.c
index 4812736..850c273 100644
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -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);
diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c
index 5a04ecc..f8a4528 100644
--- a/gdb/moxie-tdep.c
+++ b/gdb/moxie-tdep.c
@@ -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);

diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c
index b58f318..cf33a02 100644
--- a/gdb/nto-procfs.c
+++ b/gdb/nto-procfs.c
@@ -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."));
}
}
diff --git a/gdb/nto-tdep.c b/gdb/nto-tdep.c
index fddd548..7c48946 100644
--- a/gdb/nto-tdep.c
+++ b/gdb/nto-tdep.c
@@ -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 *
diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c
index 14f4ecb..ef94a48 100644
--- a/gdb/ppc-linux-nat.c
+++ b/gdb/ppc-linux-nat.c
@@ -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)
diff --git a/gdb/proc-service.c b/gdb/proc-service.c
index a1f90a8..68df6e9 100644
--- a/gdb/proc-service.c
+++ b/gdb/proc-service.c
@@ -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);
diff --git a/gdb/procfs.c b/gdb/procfs.c
index c03165a..82c7cd0 100644
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -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",
diff --git a/gdb/progspace.c b/gdb/progspace.c
index db8c5a3..ff5af0d 100644
--- a/gdb/progspace.c
+++ b/gdb/progspace.c
@@ -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;
diff --git a/gdb/python/py-finishbreakpoint.c b/gdb/python/py-finishbreakpoint.c
index 56ab775..7b2d319 100644
--- a/gdb/python/py-finishbreakpoint.c
+++ b/gdb/python/py-finishbreakpoint.c
@@ -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);
diff --git a/gdb/python/py-inferior.c b/gdb/python/py-inferior.c
index 211a643..8acf87b 100644
--- a/gdb/python/py-inferior.c
+++ b/gdb/python/py-inferior.c
@@ -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;
diff --git a/gdb/python/python.c b/gdb/python/python.c
index 97f8506..cd50e50 100644
--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -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 ();
diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c
index 0c475cb..0f9380b 100644
--- a/gdb/ravenscar-thread.c
+++ b/gdb/ravenscar-thread.c
@@ -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;
diff --git a/gdb/record.c b/gdb/record.c
index c98ed32..08ffb68 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -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. */
diff --git a/gdb/remote-m32r-sdi.c b/gdb/remote-m32r-sdi.c
index 748aeba..f7addea 100644
--- a/gdb/remote-m32r-sdi.c
+++ b/gdb/remote-m32r-sdi.c
@@ -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++)
{
diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c
index eee2460..ff5806e 100644
--- a/gdb/remote-mips.c
+++ b/gdb/remote-mips.c
@@ -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."),
diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index adc77e7..e2738a8 100644
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c
@@ -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);
}
diff --git a/gdb/remote.c b/gdb/remote.c
index 24bb9bc..be77ad1 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -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);
diff --git a/gdb/rl78-tdep.c b/gdb/rl78-tdep.c
index acd36c2..2323276 100644
--- a/gdb/rl78-tdep.c
+++ b/gdb/rl78-tdep.c
@@ -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. */
diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c
index 2d2df5b..f46169b 100644
--- a/gdb/rs6000-nat.c
+++ b/gdb/rs6000-nat.c
@@ -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. */
diff --git a/gdb/rx-tdep.c b/gdb/rx-tdep.c
index 8637c0c..5990126 100644
--- a/gdb/rx-tdep.c
+++ b/gdb/rx-tdep.c
@@ -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. */
diff --git a/gdb/s390-nat.c b/gdb/s390-nat.c
index bad1b43..ff68676 100644
--- a/gdb/s390-nat.c
+++ b/gdb/s390-nat.c
@@ -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)
diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index bd31f4f..b2c1806 100644
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c
@@ -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. */
diff --git a/gdb/solib-darwin.c b/gdb/solib-darwin.c
index 55ecb91..4ea0722 100644
--- a/gdb/solib-darwin.c
+++ b/gdb/solib-darwin.c
@@ -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);
diff --git a/gdb/solib-dsbt.c b/gdb/solib-dsbt.c
index 8276db2..9024be2 100644
--- a/gdb/solib-dsbt.c
+++ b/gdb/solib-dsbt.c
@@ -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)
diff --git a/gdb/solib-frv.c b/gdb/solib-frv.c
index 57a14a8..d259440 100644
--- a/gdb/solib-frv.c
+++ b/gdb/solib-frv.c
@@ -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;
diff --git a/gdb/solib-ia64-hpux.c b/gdb/solib-ia64-hpux.c
index f349c4c..0d2b835 100644
--- a/gdb/solib-ia64-hpux.c
+++ b/gdb/solib-ia64-hpux.c
@@ -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;

diff --git a/gdb/solib-irix.c b/gdb/solib-irix.c
index 1cec282..52378e9 100644
--- a/gdb/solib-irix.c
+++ b/gdb/solib-irix.c
@@ -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;
diff --git a/gdb/solib-pa64.c b/gdb/solib-pa64.c
index 60b3684..c37b617 100644
--- a/gdb/solib-pa64.c
+++ b/gdb/solib-pa64.c
@@ -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
diff --git a/gdb/solib-som.c b/gdb/solib-som.c
index 6fea108..47bf5a3 100644
--- a/gdb/solib-som.c
+++ b/gdb/solib-som.c
@@ -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;
diff --git a/gdb/solib-spu.c b/gdb/solib-spu.c
index f62d96c..09a4047 100644
--- a/gdb/solib-spu.c
+++ b/gdb/solib-spu.c
@@ -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;
}

diff --git a/gdb/solib-sunos.c b/gdb/solib-sunos.c
index b17ef8a..b8b3806 100644
--- a/gdb/solib-sunos.c
+++ b/gdb/solib-sunos.c
@@ -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);
}

diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 3d60aa1..37cc654 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -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);
}
diff --git a/gdb/solib.c b/gdb/solib.c
index d795678..db3842a 100644
--- a/gdb/solib.c
+++ b/gdb/solib.c
@@ -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);
diff --git a/gdb/spu-linux-nat.c b/gdb/spu-linux-nat.c
index 1932aae..1db97ce 100644
--- a/gdb/spu-linux-nat.c
+++ b/gdb/spu-linux-nat.c
@@ -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 */

diff --git a/gdb/spu-multiarch.c b/gdb/spu-multiarch.c
index 8d4ef57..5ace7c5 100644
--- a/gdb/spu-multiarch.c
+++ b/gdb/spu-multiarch.c
@@ -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. */
diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
index 8419a5a..85baf3e 100644
--- a/gdb/spu-tdep.c
+++ b/gdb/spu-tdep.c
@@ -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;
diff --git a/gdb/symfile-mem.c b/gdb/symfile-mem.c
index 2e53be0..1b1e456 100644
--- a/gdb/symfile-mem.c
+++ b/gdb/symfile-mem.c
@@ -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. */
diff --git a/gdb/symfile.c b/gdb/symfile.c
index 6cac666..55af541 100644
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -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");
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 7e16222..65542a7 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -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;
diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c
index 468fe42..12593df 100644
--- a/gdb/target-descriptions.c
+++ b/gdb/target-descriptions.c
@@ -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 "
diff --git a/gdb/target.c b/gdb/target.c
index 62de336..5015e51 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -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)
diff --git a/gdb/target.h b/gdb/target.h
index 9a8dda8..7907ee1 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -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.
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 6e55d57..912341a 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -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");
diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index 5eb8f67..a8766cd 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c
@@ -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);
diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c
index 116525c..9c89e92 100644
--- a/gdb/windows-tdep.c
+++ b/gdb/windows-tdep.c
@@ -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;

diff --git a/gdb/xcoffsolib.c b/gdb/xcoffsolib.c
index 46cf808..b72be5c 100644
--- a/gdb/xcoffsolib.c
+++ b/gdb/xcoffsolib.c
@@ -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 (). */